home *** CD-ROM | disk | FTP | other *** search
/ 5 Star Games: DOS Edition 2 / 5 Star Games - DOS Edition (1995)(Ready to Run).iso / dbc / dbc.skl < prev    next >
Text File  |  1993-12-16  |  65KB  |  2,608 lines
  1.  
  2.  
  3. #define _ENTRY_
  4.  
  5. #ifdef __TURBOC__
  6.     #include <conio.h>
  7. #else
  8.     #include <graph.h>
  9. #endif
  10. #include <io.h>
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include "db_lsc.h"
  15. #include "db_types.h"
  16. #include "db_conio.h"
  17. #include "db_curs.h"
  18. #include "db_date.h"
  19. #include "db_dos.h"
  20. #include "db_file.h"
  21. #include "extfhc.h"
  22. #include "db_funcs.h"
  23. #include "db_heap.h"
  24. #include "db_gvar.h"
  25. #include "db_key.h"
  26. #include "db_pswd.h"
  27. #include "db_sets.h"
  28. #include "db_str.h"
  29. #include "db_win.h"
  30. #include "db_mnu.h"
  31. #include "db_util.h"
  32. #include "db_work.h"
  33. #include "db_tree.h"
  34. #include "db_list.h"
  35. ⁿUSESⁿ
  36. ⁿIFDEF MANUALⁿ
  37. #include "db_man.h"
  38. ⁿENDDEFⁿ
  39. ⁿIFDEF MEMOSⁿ
  40. #include "db_memo.h"
  41. ⁿENDDEFⁿ
  42.  
  43. unsigned _stklen = 0x4000;  /* Default stack of 16 K */
  44.  
  45. string _tts, _tranString;   /* _tranString for internal generator use only */
  46.  
  47. bool specListAndAdd;
  48.  
  49. long specialadd(int fno);
  50. strptr speclistadd(keystr sout, int fno, int kno, keystr ks);
  51.  
  52.  
  53.  
  54. /*********************************  TYPES  **********************************/
  55.  
  56. typedef struct {
  57.     char exeid[9];
  58.     byte anchor;
  59.    int  deltat;
  60. } defaultrec;
  61.  
  62. typedef enum {Cmd_No_Command,
  63.           Cmd_Next_Record,
  64.           Cmd_Prev_Record,
  65.           Cmd_Find_Record,
  66.           Cmd_Top_Record,
  67.           Cmd_Last_Record,
  68.           Cmd_Edit_Record,
  69.           Cmd_Add_Record,
  70.           Cmd_Copy_Record,
  71.           Cmd_Delete_Record,
  72.           Cmd_Next_File,
  73.           Cmd_Prev_File,
  74.           Cmd_Swap_Menu
  75. }commandtyp;
  76.  
  77. ⁿIFDEF LINKEDⁿ
  78. typedef struct {
  79.     byte  f;
  80.     byte  k;
  81.     byte  l;
  82.     uchar t;
  83. } lback;
  84. ⁿENDDEFⁿ
  85.  
  86. typedef struct savmtyp {
  87.     pathstr savnam;
  88.     byte savno;
  89.     char savprompt[81];
  90.     pathstr savpath;
  91.     struct savmtyp *savprv;
  92. } savmtyp, *savmptr;
  93.  
  94. /*************************  INITIALIZED VARIABLES  **************************/
  95.  
  96. defaultrec def1 = {"öDBPSKL_",0,150};
  97.  
  98. namestr applname = "ⁿMODNAMEⁿ";
  99. pathstr localmenu = "ⁿMENUNAMEⁿ";
  100.  
  101. #define maxfilno ⁿmaxfilnoⁿ
  102. #define maxkeyno ⁿmaxkeynoⁿ
  103.  
  104. str12 dbnames[maxfilno+1][maxkeyno+1] =     /* [1.. ,0.. ] */
  105.                     ⁿdbnamesⁿ;
  106. long maxrec[maxfilno+1] =
  107.                     ⁿmaxrecⁿ;
  108. byte keymode[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  109.                     ⁿkeymodeⁿ;
  110. byte keylen[maxfilno+1][maxkeyno+1] =        /* [1.. ,1.. ] */
  111.                     ⁿkeylenⁿ;
  112. byte keyseg1len[maxfilno+1][maxkeyno+1] =
  113.            ⁿkeyseg1lenⁿ;
  114. char keyuse[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  115.                     ⁿkeyuseⁿ;
  116. char keytype[maxfilno+1][maxkeyno+1] =      /* [1.. ,1.. ] */
  117.                     ⁿkeytypeⁿ;
  118. byte keyfld[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  119.                     ⁿKeyFldⁿ;
  120. findwtyp findscrpos[maxfilno+1][maxkeyno+1] = /* [1.. ,1.. ] */
  121.                     ⁿfindscrposⁿ;
  122. bool filinuse[maxfilno+1] =
  123.                     ⁿfilinuseⁿ;
  124. byte winforfile[maxfilno+1] =
  125.                     ⁿwinforfileⁿ;
  126.  
  127. ⁿIFDEF ADJUSTⁿ
  128. int afteradj[maxfilno+1][maxfilno+1] =
  129.                     ⁿafteradjⁿ;
  130. ⁿENDDEFⁿ
  131.  
  132. ⁿIFDEF TABLESⁿ
  133. byte tabsize[maxfilno+1] =
  134.                     ⁿTableSizesⁿ;
  135. ⁿENDDEFⁿ
  136.  
  137. ⁿIFDEF LINKEDⁿ
  138. lback linkback[maxfilno+1] =
  139.                     ⁿnewlinkbackⁿ;
  140. ⁿENDDEFⁿ
  141.  
  142. str20 keynamtab[maxfilno+1][maxkeyno+1] =
  143.                     ⁿkeynamtabⁿ;
  144.  
  145. bool menudriven = ⁿmenudrivenⁿ;
  146.  
  147. /*******************************  VARIABLES  ********************************/
  148.  
  149. ⁿIFDEF TABLESⁿ
  150. bool            switchtab,leaveclear;
  151. recnotyp        tabrecno;
  152. byte            tabidx[maxfilno+1];
  153. byte            tabused[maxfilno+1];
  154. ⁿENDDEFⁿ
  155.  
  156. bool            pathSwap;
  157. savmptr         smc, svm;
  158. string          tempString;
  159. byte            menuanchor;
  160. bool            quit,fok,cleartop,scrn_active, listAndAdd;
  161. int             keynum,_trace,filno,scrno,dispsno;
  162. long            nextrec;
  163. keystr          key,skey,tempkey;
  164. mnufrec         dm;
  165. winfrec         uw,hw;
  166. winptr          twinp;
  167. int             dbsize[maxfilno+1];
  168. datafile        *datf[maxfilno+1];
  169. indexfile       *idxkey[maxfilno+1][maxkeyno+1];
  170. keystr          tkeytab[maxkeyno+1], savkey[maxkeyno+1];
  171. fldtyp          *keyseg1fld[maxfilno + 1][maxkeyno + 1];
  172.  
  173. ⁿIFDEF LINKEDⁿ
  174. string          savelnk[maxfilno+1];
  175. ⁿENDDEFⁿ
  176.  
  177. ⁿIFDEF MUSERⁿ
  178. bool            lockByDel[maxfilno+1];
  179. ⁿENDDEFⁿ
  180.  
  181. int             tv;
  182. char            lastrecop;
  183. commandtyp      command;
  184. indexfile       *primaryIdxP[maxfilno+1];                          /*MOD PK*/
  185. int             primaryKno[maxfilno+1];                            /*MOD PK*/
  186. bool            fileCanWalk[maxfilno+1];                           /*MOD PK*/
  187.  
  188.  
  189.  
  190. ⁿRECMODⁿ
  191.  
  192. bool   custom_key(int scr, int fno, int *fld, uchar *key);
  193. void   getarec(int fno);
  194. void   putarec(int fno);
  195. void   displayrec(int fno, int sno);
  196. void   clear_rec(int fno);
  197. void   traceback(int fno);                                         /*MOD PK*/
  198. void   displayall(void);                                           /*MOD PK*/
  199.  
  200.  
  201.  
  202. strptr list(strptr sout, int fno, int kno, keystr ks);
  203. strptr listadd(strptr sout, int fno, int kno, keystr aKey);
  204. strptr listOther(int fno, int kno, string fromFld, string toFld);
  205.  
  206. strptr listOther(int fno, int kno, string fromFld, string toFld)
  207. {
  208.   uchar dummy[81];
  209.   string ts;
  210.   int savelen;
  211.  
  212.   savelen = strlen(toFld);
  213.   strcpy(ts,"");
  214.   list(dummy,fno,kno,ts);
  215.   strcopy(ts,fromFld,0,savelen);
  216.   pad(ts,ts,savelen,Right);
  217.   strcpy(toFld,ts);
  218.   return(dummy);
  219. }
  220.  
  221.  
  222.  
  223.  
  224.  
  225. void tandk(int x, int y, winptr w)
  226. {
  227.     string ts;
  228.  
  229.     while (!kpressed()) {
  230.         if (mtime.x) writewxy(get_time(ts,(_timemode)(mtime.m)),0,mtime.x,mtime.y,NULL);
  231.         if (mksta.x) writewxy(keystat(ts,0),0,mksta.x,mksta.y,NULL);
  232.     }
  233. }
  234.  
  235. bool found(int fno, int kno, keystr chkkey)
  236. {
  237.     bool tok;
  238.     bool tfound;
  239.    keystr aKey;                                             /* SN 3.5 */
  240.  
  241.     tok = ok;
  242.     if ((fno != filno) && (keylen[fno][kno] > 0)) {
  243.       strcpy(aKey,chkkey);                                  /* SN 3.5 */
  244.       searchkey(idxkey[fno][kno], &recno[fno], aKey);       /* SN 3.5 */
  245.       ok = (bool)(ok && ((strsearch(aKey, chkkey) == aKey) || (strlen(chkkey) == 0)));
  246.         if (ok) switch (fno) {
  247.             ⁿgetrecⁿ
  248.         }
  249.         tfound = ok;
  250.     }
  251.     else tfound = False;
  252.  
  253.     ok = tok;
  254.    recavail[fno] = tfound;
  255.     return(tfound);
  256. }
  257.  
  258. ⁿFUNCMODⁿ
  259. ⁿSCRNMODⁿ
  260.  
  261. void openfiles(void)
  262. {
  263.     int    i, j, fo_i, fo_j;
  264.     string prepend;
  265.     int    tlen;
  266.     string ts;
  267.  
  268.     fo_i = fo_j = 0;
  269.  
  270.     ⁿSIZESⁿ;
  271.  
  272.     strip(prepend,datapath);
  273.     tlen = strlen(prepend);
  274.     if ((tlen > 0) && (prepend[tlen-1] != '\\')) {
  275.         prepend[tlen]   = '\\';
  276.       prepend[tlen+1] = '\0';
  277.     }
  278.  
  279.     fok = True;
  280.     for (i=1;i <= maxfilno; i++)
  281.         if (fok) {
  282.             datf[i] = db_malloc(sizeof(datafile));
  283.             strconcat(ts,prepend,dbnames[i][0],NULL);
  284.             openfile(datf[i],ts,dbsize[i]);
  285.             fok = (bool)(fok && ok);
  286.             if (fok) {
  287.                 fo_i = i;
  288.                 fo_j = 0;
  289.                 for (j=1; j <= maxkeyno; j++)
  290.                     if (fok && (keylen[i][j] > 0)) {
  291.                         idxkey[i][j] = db_malloc(sizeof(indexfile));
  292.                         strconcat(ts,prepend,dbnames[i][j],NULL);
  293.                         openindex(idxkey[i][j],ts,keylen[i][j],keymode[i][j]);
  294.                         fok = (bool)(fok && ok);
  295.                         if (fok) fo_j = j;
  296.                     }
  297.             }
  298.             else if (filinuse[i]) {
  299.                 strconcat(ts,prepend,dbnames[i][0],NULL);
  300.                 makefile(datf[i],ts,dbsize[i]);
  301.                 fok = ok;
  302.                 if (fok) {
  303.  
  304. ⁿIFDEF MUSERⁿ
  305.                     closefile(datf[i]);
  306.                     strconcat(ts,prepend,dbnames[i][0],NULL);
  307.                     openfile(datf[i],ts,dbsize[i]);
  308. ⁿENDDEFⁿ
  309.  
  310.                     fo_i = i;  fo_j = 0;
  311.                     for (j=1; j <= maxkeyno; j++)
  312.                         if (fok && (keylen[i][j] > 0)) {
  313.                             idxkey[i][j] = db_malloc(sizeof(indexfile));
  314.                             strconcat(ts,prepend,dbnames[i][j],NULL);
  315.                             makeindex(idxkey[i][j],ts,keylen[i][j],keymode[i][j]);
  316.                             fok = (bool)(fok && ok);
  317.                             if (fok) {
  318.  
  319. ⁿIFDEF MUSERⁿ
  320.                                 closeindex(idxkey[i][j]);
  321.                                 strconcat(ts,prepend,dbnames[i][j],NULL);
  322.                                 openindex(idxkey[i][j],ts,keylen[i][j],keymode[i][j]);
  323.                                 fo_j = j;
  324. ⁿELSEDEFⁿ
  325.                                 fo_j = j;
  326. ⁿENDDEFⁿ
  327.  
  328.                             }
  329.                         }
  330.                 }
  331.             }
  332.         }
  333.     if (!fok)
  334.         for (i=1; i <= maxfilno; i++)
  335.             if (i <= fo_i) {
  336.                 closefile(datf[i]);
  337.                 db_free(datf[i]);
  338.                 for (j=1; j <= maxkeyno; j++)
  339.                     if ((i < fo_i) || (j <= fo_j))
  340.                         if (keylen[i][j] > 0) {
  341.                             closeindex(idxkey[i][j]);
  342.                             db_free(idxkey[i][j]);
  343.                         }
  344.             }
  345. }
  346.  
  347. void closefiles(void)
  348. {
  349.     int i,j;
  350.  
  351.     for (i=1; i <= maxfilno; i++) {
  352.         closefile(datf[i]); db_free(datf[i]);
  353.         for (j=1; j <= maxkeyno; j++) if (keylen[i][j] > 0) {
  354.             closeindex(idxkey[i][j]);
  355.      db_free(idxkey[i][j]);
  356.         }
  357.     }
  358. }
  359.  
  360. ⁿIFDEF MUSERⁿ
  361. void must_secure_rec(int fno, long rno, int m)
  362. {
  363.     if (multiuser)
  364.         do {
  365.             tv = lock_datf(datf[fno],rno,Lock);
  366.             if (tv == -1)
  367.                 switch (m) {
  368.            case 1 : dspmsge(LSC_Warning,LSC_LinkedRecInUse,4.0);break;
  369.            case 2 : dspmsge(LSC_Warning,LSC_StatusRecLocked,4.0);break;
  370.                 }
  371.         } while (tv);
  372. }
  373.  
  374. bool chkabortretry(strptr instr)
  375. {
  376.     return((bool)((*instr == _Abort) || (*instr == _Retry)));
  377. }
  378.  
  379. void must_secure_index(int fno, int kno, byte lck)
  380. {
  381.     int tmp,count;
  382.     uchar again[2],retry[2],tpic[2];
  383.  
  384.     count = 0;
  385.     if (multiuser)
  386.         do {
  387.             count++;
  388.             if (count >= 1000) {
  389.                 dbgetstr(again,_Ch,LSC_Complications,chstr(retry,_Retry),chstr(tpic,Pic_U),"",chkabortretry,nohelp);
  390.                 if (*again == _Retry) count = 0;
  391.                 else {
  392.                     closefiles();
  393.                     exit(0);
  394.                 }
  395.             }
  396.             tmp = lock_indexf(idxkey[fno][kno],-1L,lck);
  397.         } while (tmp);
  398. }
  399. ⁿENDDEFⁿ
  400.  
  401. strptr makekey(strptr sout, int fno, int kno)
  402. {
  403.     string ks, ts;
  404.    string tempString;
  405.  
  406.     ks[0] = '\0';
  407.  
  408.     ⁿmakekeyⁿ
  409.  
  410.     strcpy(sout,ks);
  411.     return(sout);
  412. }
  413.  
  414. strptr keyexpr(strptr sout, int fno, int kno, string kvar)
  415. {
  416.     string ts, ks;
  417.     byte   tlen;
  418.  
  419.     strcpy(ks,kvar);
  420.     tlen = strlen(ks);
  421.  
  422.     ⁿkeyexprⁿ
  423.  
  424.     ks[tlen] = Nul;
  425.     strcpy(sout,ks);
  426.     return(sout);
  427. }
  428.  
  429. strptr getakey(strptr sout, int fno, int kno)
  430. {
  431.     string tsout;
  432.     keyexpr(sout,fno,kno,makekey(tsout,fno,kno));
  433.     return(sout);
  434. }
  435.  
  436. ⁿIFDEF LINKEDⁿ
  437. strptr getlink(strptr sout, int fno)
  438. {
  439.     string tkey;
  440.  
  441.     tkey[0] = '\0';
  442.  
  443.     ⁿGetKLinkⁿ
  444.  
  445.     strcopy(sout,tkey,0,linkback[fno].l);
  446.     return(sout);
  447. }
  448. ⁿENDDEFⁿ
  449.  
  450. void edit_rec(int fld)
  451. {
  452.     edthook = tandk;
  453.  
  454. ⁿIFDEF TABLESⁿ
  455.     ⁿMODNAMEⁿ_edt(filno,fld,tabidx[filno] - 1);
  456. ⁿELSEDEFⁿ
  457.     ⁿMODNAMEⁿ_edt(filno,fld,0);
  458. ⁿENDDEFⁿ
  459.  
  460.     edthook = NULL;
  461. }
  462.  
  463. bool status_ok(int fno)
  464. {
  465.     bool tok;
  466.     keystr tk1, tk2;
  467.  
  468.     tok = (bool)(usedrecs(datf[fno]) > 0);
  469.  
  470. ⁿIFDEF LINKEDⁿ
  471.     if (linkback[fno].f > 0) {
  472.         getlink(tk1,fno);
  473.         strcopy(tk2,getakey(tk2,fno,1),0,linkback[fno].l);
  474.         tok = (bool)(tok && recavail[linkback[fno].f] && (strcmp(tk1,tk2) == 0));
  475.     }
  476. ⁿENDDEFⁿ
  477.  
  478.    recavail[fno] = tok;
  479.     return(tok);
  480. }
  481.  
  482. void clearbuf(ptr fb)
  483. {
  484.     word    w;
  485.     string  tpic;
  486.     fldblk *fblk;
  487.     fldtyp *ftp;
  488.  
  489.     fblk = fb;
  490.     for (w=0; w < fblk->numf; w++) {
  491.         ftp = &(*fblk->farr)[w];
  492.         expand(tpic,ftp->pic);
  493.         switch (ftp->typ) {
  494.             case _Ch   : fillstr(ftp->faddr,piclen(tpic,ftp->typ),' '); break;
  495.             case _Num  : fstr(ftp->faddr,0.0,_calc_int(tpic),_calc_frac(tpic)); break;
  496.  
  497. ⁿIFDEF MEMOSⁿ
  498.             case _Memo : memset(ftp->faddr,0,4); break;
  499. ⁿENDDEFⁿ
  500.  
  501.         }
  502.     }
  503. }
  504.  
  505. ⁿIFDEF MEMOSⁿ
  506. void clearmemo(ptr fb)
  507. {
  508.     word w;
  509.     fldblk *fblk;
  510.     bool memofile;
  511.     fldtyp *ftp;
  512.  
  513.     fblk = fb;
  514.     memofile = False;
  515.     for (w=0; w < fblk->numf; w++) {
  516.         ftp = &(*fblk->farr)[w];
  517.         if (ftp->typ == _Memo) {
  518.             memofile = True;
  519.             memset(ftp->faddr,0,4);
  520.         }
  521.     }
  522.     if (memofile)   displayrec(filno,scrno);
  523. }
  524. ⁿENDDEFⁿ
  525.  
  526. void clear_rec(int fno)
  527. {
  528.  
  529. ⁿIFDEF LINKEDⁿ
  530.     int i;
  531.  
  532.     if (link == Up_N_Down)
  533.         for (i=1; i <= maxfilno; i++)
  534.             if (linkback[i].f == (byte)fno) clear_rec(i);
  535. ⁿELSEDEFⁿ
  536. ⁿENDDEFⁿ
  537.  
  538.     if (cleartop || (fno != filno)) {
  539.         switch (fno) {
  540.             ⁿCLEARBUFⁿ
  541.         }
  542.         displayrec(fno,scrno);
  543.     }
  544. }
  545.  
  546. /* SN 3.5 - the whole function was created for this version 3.5 */
  547.  
  548. long add2CodeFile(int fileNumber)
  549. {
  550.    bool    saveOk,
  551.         aOk;
  552.    byte    keyNumber, keyNumberCount;
  553.    keystr  aKey;
  554.    char   *aBufferPtr,
  555.            *aFieldPtr,
  556.         errorMessage[256];
  557.  
  558.  
  559.  
  560.    saveOk                = ok;
  561.    *(recno + fileNumber) = 0;
  562.  
  563.    switch(fileNumber) {
  564.  
  565.       ⁿCODEFILEBUFⁿ
  566.  
  567.       default :
  568.           aBufferPtr = aFieldPtr = 0;
  569.           break;
  570.    }
  571.  
  572.    if (aBufferPtr) {
  573.       clearbuf(aFieldPtr);
  574.       memmove(aBufferPtr, &recno[fileNumber], 4);
  575.       do {
  576.           ok = False;
  577.           editdefaultdata(fileNumber, aFieldPtr);
  578.           if (exitcode != QitKey) {
  579. ⁿIFDEF MUSERⁿ
  580.          must_secure_rec(fileNumber, 0, 2);
  581. ⁿENDDEFⁿ
  582.          addrec(datf[fileNumber], &recno[fileNumber], aBufferPtr);
  583. ⁿIFDEF MUSERⁿ
  584.          tv = lock_datf(datf[fileNumber], recno[fileNumber], Lock);
  585.          tv = lock_datf(datf[fileNumber], 0, UnLock);
  586. ⁿENDDEFⁿ
  587.          keyNumber = 0;
  588.          ok        = True;
  589.          while (ok && (keyNumber < maxkeyno)) {
  590.                keyNumber++;
  591.                if (keylen[fileNumber][keyNumber]) {
  592.                    getakey(aKey, fileNumber, keyNumber);
  593. ⁿIFDEF MUSERⁿ
  594.                    must_secure_index(fileNumber, keyNumber, Lock);
  595.                    addkey(idxkey[fileNumber][keyNumber], &recno[fileNumber], aKey);
  596.                    must_secure_index(fileNumber, keyNumber, UnLock);
  597. ⁿELSEDEFⁿ
  598.                    addkey(idxkey[fileNumber][keyNumber], &recno[fileNumber], aKey);
  599. ⁿENDDEFⁿ
  600.                }
  601.          }
  602.          if (!ok) {
  603.             audible(Error);
  604.             dspmsge(LSC_BaseError, strconcat(errorMessage, LSC_KeyExists, "(", keynamtab[fileNumber][keyNumber], ")"), 4);
  605.             for (keyNumberCount = 1; keyNumberCount < keyNumber; keyNumberCount++) {
  606.                if (keylen[fileNumber][keyNumberCount]) {
  607.                  getakey(aKey, fileNumber, keyNumberCount);
  608. ⁿIFDEF MUSERⁿ
  609.                  must_secure_index(fileNumber, keyNumberCount, Lock);
  610.                  deletekey(idxkey[fileNumber][keyNumberCount], &recno[fileNumber], aKey);
  611.                  must_secure_index(fileNumber, keyNumberCount, UnLock);
  612. ⁿELSEDEFⁿ
  613.                  deletekey(idxkey[fileNumber][keyNumberCount], &recno[fileNumber], aKey);
  614. ⁿENDDEFⁿ
  615.                }
  616.             }
  617.  
  618. ⁿIFDEF MUSERⁿ
  619.             must_secure_rec(fileNumber, 0, 2);
  620.             deleterec(datf[fileNumber], recno[fileNumber]);
  621.             tv = lock_datf(datf[fileNumber], 0, UnLock);
  622. ⁿELSEDEFⁿ
  623.             deleterec(datf[fileNumber], recno[fileNumber]);
  624. ⁿENDDEFⁿ
  625.  
  626.             ok = False;
  627.          }
  628.  
  629. ⁿIFDEF MUSERⁿ
  630.          tv = lock_datf(datf[fileNumber], recno[fileNumber], UnLock);
  631. ⁿENDDEFⁿ
  632.           }
  633.       }while (!ok && (exitcode != QitKey));
  634.  
  635.       if (exitcode == QitKey) {
  636.           clearbuf(aFieldPtr);
  637.           recno[fileNumber] = 0;
  638.       }
  639.    }
  640.  
  641.    ok       = saveOk;
  642.    exitcode = Nul;
  643.    return(recno[fileNumber]);
  644. }
  645. bool skip(char dirn, int fno)
  646. {
  647.     bool fval;
  648.     string ts;
  649.  
  650.     fval = True;
  651.     if (dirn == _Next) nextkey(primaryIdxP[fno],&recno[fno],key);    /*MOD PK*/
  652.     else               prevkey(primaryIdxP[fno],&recno[fno],key);    /*MOD PK*/
  653. ⁿIFDEF LINKEDⁿ
  654.     if ((linkback[fno].f > 0) && !fileCanWalk[fno])                  /*MOD PK*/
  655.     ok = (bool)(ok && (strsearch(key,getlink(ts,fno)) == key));
  656. ⁿENDDEFⁿ
  657.     if (!ok) {
  658.         fval = False;
  659.         if (dirn == _Next) prevkey(primaryIdxP[fno],&recno[fno],key);  /*MOD PK*/
  660.         else               nextkey(primaryIdxP[fno],&recno[fno],key);  /*MOD PK*/
  661.     }
  662.     return(fval);
  663. }
  664.  
  665. void getarec(int fno)
  666. {
  667.     int i;
  668.     string tkey;
  669.     string ts;
  670.  
  671. ⁿIFDEF LINKEDⁿ
  672. ⁿIFDEF TABLESⁿ
  673.     bool tb;
  674. ⁿENDDEFⁿ
  675. ⁿENDDEFⁿ
  676.  
  677.     tkey[0] = '\0';
  678.     recavail[fno] = ok;
  679.     if (ok)
  680.         switch (fno) {
  681.             ⁿGETRECⁿ
  682.         }
  683. ⁿIFDEF LINKEDⁿ
  684.     if ((!recavail[fno]) ||
  685.             ((link != No_Link) && (_trace != fno) && !status_ok(fno))) {
  686.         recavail[fno] = False;
  687. ⁿIFDEF TABLESⁿ
  688.         tb          = scrn_active;
  689.         scrn_active = False;
  690.         clear_rec(fno);
  691.         scrn_active = tb;
  692. ⁿELSEDEFⁿ
  693.         clear_rec(fno);
  694. ⁿENDDEFⁿ
  695.     }
  696.     if (link != No_Link) {
  697. ⁿIFDEF TABLESⁿ
  698.         if ((tabsize[fno] > 1) && (fno != filno) && !switchtab) {
  699.             tabrecno[fno] = recno[fno]; tabidx[fno] = 1;
  700.         }
  701. ⁿENDDEFⁿ
  702.         for (i=1; i <= maxfilno; i++)
  703.             if (linkback[i].f == (byte)fno)
  704.                 if (!status_ok(i)) {
  705.                     getlink(tkey,i);
  706.                     searchkey(idxkey[i][1],&recno[i],tkey);
  707.                     ok = (bool)(ok && (strsearch(tkey,getlink(ts,i)) == tkey));
  708.                     getarec(i); /* recursion */
  709.                 }
  710.     }
  711. ⁿELSEDEFⁿ
  712.     if (!recavail[fno] || !status_ok(fno)) {
  713.         recavail[fno] = False;
  714.         clear_rec(fno);
  715.     }
  716. ⁿENDDEFⁿ
  717.     if (fno == filno) ok = recavail[fno];
  718. }
  719.  
  720. void putarec(int fno)
  721. {
  722.    if (recavail[fno]) {
  723.        switch (fno) {
  724.                ⁿPUTRECⁿ
  725.        }
  726.    }
  727. }
  728.  
  729. ⁿIFDEF LINKEDⁿ
  730. void lookupline(int fno)                                           /*MOD PK*/
  731. {                                                                  /*MOD PK*/
  732.   keystr tk1, tk2;                                                 /*MOD PK*/
  733.                                    /*MOD PK*/
  734.   if ((linkback[fno].f > 0) && (fileCanWalk[fno])) {               /*MOD PK*/
  735.     switch (fno) {                                                 /*MOD PK*/
  736.       ⁿGETRECⁿ                                                     /*MOD PK*/
  737.     }                                                              /*MOD PK*/
  738.         if (strcmp(getlink(tk1,fno),                                   /*MOD PK*/
  739.     strcopy(tk2,getakey(tk2,fno,1),0,linkback[fno].l)) != 0) { /*MOD PK*/
  740.       traceback(fno);                                              /*MOD PK*/
  741.       displayall();                                                /*MOD PK*/
  742.     }                                                              /*MOD PK*/
  743.   }                                                                /*MOD PK*/
  744. }                                                                  /*MOD PK*/
  745. ⁿENDDEFⁿ
  746.  
  747. void top_record(void)
  748. {
  749. ⁿIFDEF LINKEDⁿ
  750.     if ((linkback[filno].f == 0) || (fileCanWalk[filno])) {          /*MOD PK*/
  751.         clearkey(primaryIdxP[filno]);                                  /*MOD PK*/
  752.         nextkey(primaryIdxP[filno],&recno[filno],key);                 /*MOD PK*/
  753.     lookupline(filno);                                             /*MOD PK*/
  754.     }
  755.     else {
  756.         getlink(tempkey,filno);
  757.         strcpy(skey,tempkey);
  758.         searchkey(idxkey[filno][1],&recno[filno],tempkey);
  759.         ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  760.     }
  761. ⁿELSEDEFⁿ
  762.     clearkey(primaryIdxP[filno]);                                    /*MOD PK*/
  763.     nextkey(primaryIdxP[filno],&recno[filno],key);                   /*MOD PK*/
  764. ⁿENDDEFⁿ
  765.     if (ok)
  766.         getarec(filno);
  767.     else {
  768.         recavail[filno] = False;
  769.         clear_rec(filno);
  770.     }
  771. ⁿIFDEF TABLESⁿ
  772.     if (tabsize[filno] > 1) {
  773.         tabrecno[filno] = recno[filno]; tabidx[filno] = 1;
  774.     }
  775. ⁿENDDEFⁿ
  776.     displayrec(filno,scrno);
  777. }
  778.  
  779. void findmulti(int fno, long *recn, strptr key2find)
  780. {
  781.     long saverecn;
  782.     keystr savk2f;
  783.  
  784.     saverecn = *recn;
  785.     strcpy(savk2f,key2find);
  786.     searchkey(primaryIdxP[fno],recn,key2find);                       /*MOD PK*/
  787.     ok = (bool)(ok && (strsearch(key2find,savk2f) == key2find));
  788.     while ((*recn != saverecn) && ok) {
  789.         nextkey(primaryIdxP[fno],recn,key2find);                       /*MOD PK*/
  790.         ok = (bool)(ok && (strsearch(key2find,savk2f) == key2find));
  791.     }
  792. }
  793.  
  794. ⁿIFDEF TABLESⁿ
  795. void gettabrec(byte fno)
  796. {
  797.     switch (fno) {
  798.         ⁿGetTabRecⁿ
  799.     }
  800. }
  801.  
  802. void disptab(byte fno)
  803. {
  804.     byte incy;
  805.     recnotyp srecno;
  806.     bool rec_ok, savedisp;
  807.     string tk;
  808.  
  809.     if (tabsize[fno] < 2) {
  810.         incy = tabidx[fno]-1;
  811.         ⁿMODNAMEⁿ_dsp(fno,dispsno,incy);
  812.     }
  813.     else {
  814.         incy = 0;
  815.         rec_ok = recavail[fno];
  816.         if (rec_ok) {
  817.  
  818.  
  819.       memmove(srecno,recno,sizeof(recnotyp));
  820. ⁿIFDEF LINKEDⁿ
  821.             if (!leaveclear || (linkback[fno].f != (byte)filno)) gettabrec(fno);
  822. ⁿELSEDEFⁿ
  823.             if (!leaveclear) gettabrec(fno);
  824. ⁿENDDEFⁿ
  825.             getakey(tk,fno,primaryKno[fno]);                             /*MOD PK*/
  826.             findmulti(fno,&tabrecno[fno],tk);
  827.             if (!ok) {
  828.                 scrn_active = False;
  829.                 clear_rec(fno);
  830.                 scrn_active = True;
  831.                 rec_ok = False;
  832.             }
  833.             if ((tabidx[fno] > tabsize[fno]) && (skip(_Next,fno))) {
  834.                 tabidx[fno] = tabsize[fno];
  835.                 tabrecno[fno] = recno[fno];
  836.                 gettabrec(fno);
  837.             }
  838.             if ((tabidx[fno] == 0) && (skip(_Prev,fno))) {
  839.                 tabidx[fno] = 1;
  840.                 tabrecno[fno] = recno[fno];
  841.                 gettabrec(fno);
  842.             }
  843.         }
  844.     savedisp = (uw.wa[dispsno])->disp;
  845.         (uw.wa[dispsno])->disp = False;
  846.         tabused[fno] = 0;
  847.         do {
  848.             ⁿMODNAMEⁿ_dsp(fno,dispsno,incy);
  849.             incy++;
  850.             if (rec_ok && (incy < tabsize[fno])) {
  851.                 tabused[fno] = incy;
  852.                 link = No_Link;
  853. ⁿIFDEF LINKEDⁿ
  854.                 if ((!leaveclear || (linkback[fno].f != (byte)filno)) && recavail[fno]) {
  855. ⁿELSEDEFⁿ
  856.                 if (!leaveclear && recavail[fno]) {
  857. ⁿENDDEFⁿ
  858.                     if (skip(_Next,fno)) getarec(fno);
  859.                     else {
  860.                         scrn_active = False;
  861.                         clear_rec(fno);
  862.                         scrn_active = True;
  863.                         rec_ok = False;
  864.                     }
  865.                 }
  866.                 else {
  867.                     scrn_active = False;
  868.                     clear_rec(fno);
  869.                     scrn_active = True;
  870.                     rec_ok = False;
  871.                 }
  872.                 link = Up_N_Down;
  873.             }
  874.         } while (incy < tabsize[fno]);
  875.     if (savedisp) {
  876.       (uw.wa[dispsno])->disp = True; dispwindow(uw.wa[dispsno]);
  877.     }
  878.         if (recavail[fno]) {
  879.       memmove(recno,srecno,sizeof(recnotyp));
  880. ⁿIFDEF LINKEDⁿ
  881.             if (!leaveclear || (linkback[fno].f != (byte)filno)) getarec(fno);
  882. ⁿELSEDEFⁿ
  883.             if (!leaveclear) getarec(fno);
  884. ⁿENDDEFⁿ
  885.             else {
  886.                 link = No_Link;
  887.                 getarec(fno);
  888.                 link = Up_N_Down;
  889.             }
  890.             getakey(tk,fno,primaryKno[fno]);                             /*MOD PK*/
  891.             findmulti(fno,&srecno[fno],tk);
  892.         }
  893.     }
  894. }
  895. ⁿENDDEFⁿ
  896.  
  897. void dispfields(int fno, int sno)
  898. {
  899. ⁿIFDEF TABLESⁿ
  900.     dispsno = sno;
  901. ⁿENDDEFⁿ
  902.     switch (sno) {
  903.         ⁿDispFieldsⁿ
  904.     }
  905. }
  906.  
  907. void displayrec(int fno, int sno)
  908. {
  909.     if (scrn_active) dispfields(fno,sno);
  910. }
  911.  
  912. void switch_file(char mode)
  913. {
  914.     int fno,incr;
  915.  
  916.     scrn_active = True;
  917.     if (mode == '+')      incr = 1;
  918.    else if (mode == '-') incr = -1;
  919.     else             incr = 0;
  920.     fno = filno;
  921.     do {
  922.         filno += incr;
  923.         if ((filno < 1) || (filno > maxfilno)) {
  924.             incr = -incr; filno += incr;
  925.             audible(Warning);
  926.         }
  927.     } while (!filinuse[filno] && (filno != fno));
  928.  
  929.     if (scrno < winforfile[filno]) displayrec(filno,scrno);
  930.     while (scrno > winforfile[filno]) {
  931.         hidewin(T_OFF,uw.wa[scrno]);
  932.  
  933.       scrno--;
  934.     }
  935.  
  936.     while (scrno < winforfile[filno]) {
  937.         scrno++;
  938.       hidewin(T_ON,uw.wa[scrno]);
  939.     }
  940.  
  941.     if (!status_ok(filno)) top_record(); else ok = True;
  942. ⁿIFDEF TABLESⁿ
  943.     switchtab = True;
  944.     displayrec(filno,scrno);
  945.     switchtab = False;
  946. ⁿELSEDEFⁿ
  947.     displayrec(filno,scrno);
  948. ⁿENDDEFⁿ
  949. }
  950.  
  951.  
  952. ⁿIFDEF LINKEDⁿ
  953.  
  954. void traceback(int fno)
  955. {
  956.     string tk,sk;
  957.     int f,k;
  958.  
  959.     f = linkback[fno].f;
  960.     k = linkback[fno].k;
  961.     _trace = f;
  962.     if (recavail[fno]) {
  963.         strcopy(tk,getakey(tk,fno,1),0,linkback[fno].l); strcpy(sk,tk);
  964.         searchkey(idxkey[f][k],&recno[f],tk);
  965.         ok = (bool)(ok && (strsearch(tk,sk) == tk));
  966.         if (ok) {
  967.             getarec(f);
  968.             ok = status_ok(fno);
  969. ⁿIFDEF TABLESⁿ
  970.             if (tabsize[f] > 1) {
  971.                 tabrecno[f] = recno[f]; tabidx[f] = 1;
  972.             }
  973. ⁿENDDEFⁿ
  974.             if (ok && (k != primaryKno[f])) {                            /*MOD PK*/
  975.                 getakey(tk,f,primaryKno[f]);                               /*MOD PK*/
  976.                 findmulti(f,&recno[f],tk);
  977.             }
  978.         }
  979.     }
  980.     else ok = True;
  981.  
  982.     if (!ok) {
  983.         audible(Error);
  984.         dspmsge(LSC_BaseError,LSC_TracebackFailed,4.0);
  985.         filno = 1;
  986.         switch_file(' ');
  987.         top_record();
  988.     }
  989.     else
  990.         if (linkback[f].f > 0)
  991.             traceback(f);
  992.     _trace = 0;
  993.     ok = status_ok(fno);
  994. }
  995. ⁿENDDEFⁿ
  996.  
  997. ⁿIFDEF TABLESⁿ
  998. void align_tab(int fno)
  999. {
  1000.     byte count;
  1001.     long srno;
  1002.     string ts;
  1003.  
  1004.     getakey(tempkey,fno,primaryKno[fno]);                            /*MOD PK*/
  1005.     strcpy(skey,tempkey);
  1006.     srno = recno[fno];
  1007.     count = 1;
  1008.     do {
  1009.         prevkey(primaryIdxP[fno],&recno[fno],tempkey);                 /*MOD PK*/
  1010. ⁿIFDEF LINKEDⁿ
  1011.         if (linkback[fno].f > 0) ok = (bool)(ok && (strsearch(tempkey,getlink(ts,fno)) == tempkey));
  1012. ⁿENDDEFⁿ
  1013.         if (ok) count++;
  1014.     } while ((count <= tabsize[fno]) && ok);
  1015.  
  1016.     if (!ok) nextkey(primaryIdxP[fno],&recno[fno],tempkey);          /*MOD PK*/
  1017.     tabidx[fno]   = count;
  1018.    tabrecno[fno] = recno[fno];
  1019.     recno[fno]    = srno;
  1020.     findmulti(filno,&recno[fno],skey);
  1021. }
  1022. ⁿENDDEFⁿ
  1023.  
  1024. void displayall(void)
  1025. {
  1026.     int i;
  1027.  
  1028.     for (i=1; i <= filno; i++) (uw.wa[winforfile[i]])->disp = False;
  1029. ⁿIFDEF TABLESⁿ
  1030.     link = No_Link;
  1031.     for (i=1; i <= scrno; i++) displayrec(0,i);
  1032.     link = Up_N_Down;
  1033. ⁿELSEDEFⁿ
  1034.     for (i=1; i <= scrno; i++) displayrec(filno,i);
  1035. ⁿENDDEFⁿ
  1036.     for (i=1; i <= filno; i++) hidewin(T_ON,uw.wa[winforfile[i]]);
  1037. }
  1038.  
  1039. void align_rec(long oldr)
  1040. {
  1041.     int i;
  1042.  
  1043.     ok           = True;
  1044.     _trace       = filno;
  1045.     recno[filno] = oldr;
  1046.     scrn_active  = False;
  1047.     if (oldr > 0) getarec(filno);
  1048.    else          recavail[filno] = False;
  1049.  
  1050.     if (recavail[filno]) {
  1051.         getakey(skey,filno,primaryKno[filno]);                         /*MOD PK*/
  1052.         findmulti(filno,&oldr,skey);
  1053.         if (!ok) {
  1054.             audible(Error);
  1055.             dspmsge(LSC_BaseError,LSC_Mismatch,4.0);
  1056. ⁿIFDEF MUSERⁿ
  1057.             filno = 1; scrno = 1;
  1058. ⁿENDDEFⁿ
  1059.             top_record();
  1060.         }
  1061.     }
  1062.     else top_record();
  1063. ⁿIFDEF LINKEDⁿ
  1064.     if (linkback[filno].f > 0) traceback(filno);
  1065. ⁿENDDEFⁿ
  1066. ⁿIFDEF TABLESⁿ
  1067.     if (tabsize[filno] > 1) align_tab(filno);
  1068. ⁿENDDEFⁿ
  1069.     _trace = 0;
  1070.     scrn_active = True;
  1071.     displayall();
  1072. }
  1073.  
  1074. void next_record(char dirn)
  1075. {
  1076.     long savr;
  1077.  
  1078.     if (status_ok(filno)) {
  1079.         savr = recno[filno];
  1080.         if (skip(dirn,filno)) {
  1081. ⁿIFDEF LINKEDⁿ
  1082.       lookupline(filno);                                           /*MOD PK*/
  1083. ⁿENDDEFⁿ
  1084.             getarec(filno);
  1085. ⁿIFDEF TABLESⁿ
  1086.             if (tabsize[filno] > 1)
  1087.                 if (dirn == _Next) tabidx[filno]++; else tabidx[filno]--;
  1088. ⁿENDDEFⁿ
  1089.             if (!recavail[filno]) align_rec(savr);
  1090.             else                  displayrec(filno,scrno);
  1091.         }
  1092.         else audible(Warning);
  1093.         if (!ok) top_record();
  1094.     }
  1095.     else audible(Warning);
  1096. }
  1097.  
  1098. ⁿIFDEF TABLESⁿ
  1099. void next_tab_page(char dirn)
  1100. {
  1101.     byte count;
  1102.  
  1103.     if ((tabsize[filno] > 1) && status_ok(filno)) {
  1104.         count = 1;
  1105.         while ((count < tabsize[filno]) && skip(dirn,filno)) count++;
  1106.         getarec(filno);
  1107.         align_tab(filno);
  1108.         displayrec(filno,scrno);
  1109.     }
  1110. }
  1111. ⁿENDDEFⁿ
  1112.  
  1113.  
  1114. void last_record(void)
  1115. {
  1116.     long savr;
  1117.  
  1118.     if (status_ok(filno)) {
  1119.         savr = recno[filno];
  1120. ⁿIFDEF LINKEDⁿ
  1121.         if ((linkback[filno].f == 0) || (fileCanWalk[filno])) {        /*MOD PK*/
  1122.             clearkey(primaryIdxP[filno]);                                /*MOD PK*/
  1123.             prevkey(primaryIdxP[filno],&recno[filno],key);               /*MOD PK*/
  1124.       lookupline(filno);                                           /*MOD PK*/
  1125.         }
  1126.         else {
  1127.             getlink(tempkey,filno);
  1128.             strcpy(skey,tempkey);
  1129.             searchkey(idxkey[filno][1],&recno[filno],tempkey);
  1130.             ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  1131.             if (ok) {
  1132.                 while (ok) {
  1133.                     nextkey(idxkey[filno][1],&recno[filno],tempkey);
  1134.                     ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  1135.                 }
  1136.                 prevkey(idxkey[filno][1],&recno[filno],tempkey);
  1137.             }
  1138.         }
  1139. ⁿELSEDEFⁿ
  1140.         clearkey(primaryIdxP[filno]);                                  /*MOD PK*/
  1141.         prevkey(primaryIdxP[filno],&recno[filno],key);                 /*MOD PK*/
  1142. ⁿENDDEFⁿ
  1143.         if (!ok) top_record();
  1144.         else {
  1145.             getarec(filno);
  1146. ⁿIFDEF TABLESⁿ
  1147.             if (tabsize[filno] > 1) align_tab(filno);
  1148. ⁿENDDEFⁿ
  1149.             if (!recavail[filno]) align_rec(savr);
  1150.             else                  displayrec(filno,scrno);
  1151.         }
  1152.     }
  1153.     else audible(Warning);
  1154. }
  1155.  
  1156. strptr horizrec(strptr sout, uchar mode, byte fno, byte kno)
  1157. {
  1158.     string ts;
  1159.  
  1160.    strcpy(ts, "~");
  1161.     if (mode == _Header) {
  1162.         switch (fno) {
  1163.             ⁿSELHEADERⁿ
  1164.         }
  1165.         if (ts[0] == '~') strconcat(ts,LSC_DispSequence," ",keynamtab[fno][kno],NULL);
  1166.     }
  1167.     else {
  1168.         switch (fno) {
  1169.             ⁿSELDETAILⁿ
  1170.         }
  1171.     }
  1172.     pad(sout,ts,255,Right);
  1173.     return(sout);
  1174. }
  1175.  
  1176. void display_the_find(long trecno, long oldnum)
  1177. {
  1178.     align_rec(trecno ? trecno : oldnum);
  1179. }
  1180.  
  1181. void find_record(void)
  1182. {
  1183.     int    tpos,i, dsplen;
  1184.     bool   tb,abort;
  1185.     char   temp_pic[DB_Klen+1];
  1186.     long   trecno,oldnum;
  1187.     char   chosen[21];
  1188.     string numstr, choosestr;
  1189.     string ts;
  1190.    string aPictureField;
  1191.    uchar  aFieldType;
  1192.  
  1193.    exitcode = ' ';
  1194.     if ((usedrecs(datf[filno]) > 0) && (filinuse[filno])) {
  1195.         oldnum = (recavail[filno]) ? recno[filno] : 0;
  1196.         if ((keynum > maxkeyno) || (keylen[filno][keynum] == 0)) keynum = 1;
  1197.         abort = False;
  1198.       dsplen       = 0;
  1199.       for (i = 1; i <= maxkeyno; ++i) dsplen = max(dsplen,strlen(keynamtab[filno][i]));
  1200.       if (((dsplen+1)*maxkeyno) > 255) dsplen = 14;
  1201.       i            = keynum;
  1202.       choosestr[0] = '\0';
  1203.       numstr[0]    = '\0';
  1204.         do {
  1205.            if ((keylen[filno][i] != 0) && (keynamtab[filno][i][0] != '\0')) {
  1206.                 strconcat(numstr,numstr,istr(ts,(long)i,2),"|",NULL);
  1207.                 strconcat(choosestr,choosestr,pad(ts,strcopy(ts,keynamtab[filno][i],0,dsplen),dsplen,Right),"|",NULL);
  1208.             }
  1209.             i++;
  1210.             if (i > maxkeyno) i = 1;
  1211.         } while (i != keynum);
  1212.         gotoxy((scrwid-20)/2,scrhgt-maxkeyno-4);
  1213.         tb        = permitesc;
  1214.       permitesc = True;
  1215.  
  1216.       i         = strlen(numstr);
  1217.       if (!i) exitcode = QitKey;
  1218.       else    if (i == 3) strcopy(chosen, numstr, 0, 2);
  1219.           else        choose(key, numstr, choosestr, chosen);
  1220.  
  1221.         permitesc = tb;
  1222.         if (chosen[0] != 0) keynum = (int) ival(chosen);
  1223.         abort = (bool)(exitcode == QitKey);
  1224.         if (!abort) {
  1225.             strconcat(ts," ",LSC_EnterTheKey," : ",trim(ts,keynamtab[filno][keynum])," ",NULL);
  1226.             if (openwin(0,2,scrhgt-2,78,1,31,31,8,"─┐│┘─└│┌",TopCnt,ts)) {
  1227.                 twinp = curwin;
  1228.         twinp->disp = True;
  1229.         dispwindow(twinp);
  1230.                 fillstr(key,DB_Klen,' ');
  1231.                 strchcat(strip(temp_pic,istr(temp_pic,(long)DB_Klen,3)),Pic_X);
  1232.                 tpos = (78-(strlen(LSC_EnterOrEsc)+DB_Klen+2))/2;
  1233.                 writewxy(LSC_EnterOrEsc,31,(byte)tpos,1,twinp);
  1234.                 tpos = tpos + strlen(LSC_EnterOrEsc) + 1;
  1235.  
  1236.         strcpy(aPictureField, keyseg1fld[filno][keynum]->pic);
  1237.         aFieldType = keyseg1fld[filno][keynum]->typ;
  1238.  
  1239.         expand(choosestr, aPictureField);
  1240.         switch (aFieldType) {
  1241.            case _Ch   : {
  1242.                    fillstr(choosestr, piclen(choosestr, aFieldType), ' ');
  1243.                    break;
  1244.                 }
  1245.            case _Num  : {
  1246.                    fstr(choosestr, 0.0, _calc_int(choosestr), _calc_frac(choosestr));
  1247.                    break;
  1248.                 }
  1249.         }
  1250.  
  1251.                 dsp_fld(tpos,1,choosestr, aFieldType, aPictureField, 1, 40, 0, twinp);
  1252.                 edt_fld(tpos,1,choosestr, aFieldType, aPictureField, 40, 0, twinp);
  1253.                 *skey = '\0';
  1254.         strcopy(key,choosestr,0,keyseg1len[filno][keynum]);
  1255.         if (aFieldType == _Num && (valu(key) == 0)) *key = '\0';
  1256.         pic_fld(choosestr, choosestr, aFieldType, 0, 0, aPictureField);
  1257.  
  1258.                 closewin(&twinp);
  1259.     if (fileCanWalk[filno]) {                                  /*MOD PK*/
  1260.       primaryKno[filno] = keynum;                              /*MOD PK*/
  1261.       primaryIdxP[filno] = idxkey[filno][keynum];              /*MOD PK*/
  1262.       if (exitcode == Esc) align_rec(oldnum);                  /*MOD PK*/
  1263.     }                                                          /*MOD PK*/
  1264.                 if (exitcode == Esc) goto Find_Exit;
  1265.                 if (!empty(key)) {
  1266.                     trim(key,keyexpr(key,filno,keynum,key));
  1267.            strcpy(skey,key);
  1268.                 }
  1269.                 searchkey(idxkey[filno][keynum],&recno[filno],key);
  1270.                 if ((!ok) || ((strsearch(key,skey) != key) && (strlen(skey) > 0))) {
  1271.                     audible(Warning);
  1272.            strconcat(ts, LSC_NoExactMatch, choosestr, NULL);
  1273.            strcopy (ts, ts, 0, 76);
  1274.            dspmsge("",ts,4.0);
  1275.                 }
  1276.                 tempkey[0] = '\0';
  1277.                 if (ok) {
  1278.                     nextkey(idxkey[filno][keynum],&recno[filno],key);
  1279.                     if (ok) strcpy(tempkey,key);
  1280.                     prevkey(idxkey[filno][keynum],&recno[filno],key);
  1281.                 }
  1282.                 else prevkey(idxkey[filno][keynum],&recno[filno],key);
  1283.                 if (!skey[0] || (strsearch(key,skey) != key) || (strsearch(tempkey,skey) == tempkey)) {
  1284.                 if (strsearch(key,skey) != key) key[0] = '\0'; else trim(key,skey);
  1285.                     trecno = list_n_choose((byte)filno,(byte)keynum,key,idxkey[filno][keynum],findscrpos[filno][keynum]);
  1286.                     display_the_find(trecno,oldnum);
  1287.                 }
  1288.                 else align_rec(recno[filno]);
  1289.             }
  1290.         }
  1291.     }
  1292.     else audible(Warning);
  1293. Find_Exit : ;
  1294.    exitcode = ' ';
  1295. }
  1296.  
  1297. strptr list(strptr sout, int fno, int kno, keystr ks)
  1298. {
  1299.   long trecno;
  1300.   keystr lastks;
  1301.   keystr savks;
  1302.   bool tok;
  1303. ⁿIFDEF TABLESⁿ
  1304.   byte stabsiz;
  1305. ⁿENDDEFⁿ
  1306.  
  1307.   if (!(listAndAdd || specListAndAdd)) listing = True;   /*MOD*/
  1308.  
  1309.   if ((fno != filno) && (keylen[fno][kno] > 0)) {
  1310.     tok         = ok;
  1311.     scrn_active = False;
  1312.     keyexpr(lastks,fno,kno,ks);
  1313.     trim(savks,lastks);
  1314.     searchkey(idxkey[fno][kno],&recno[fno],lastks);
  1315.     if (!ok) {
  1316.       clearkey(idxkey[fno][kno]);
  1317.       nextkey(idxkey[fno][kno],&recno[fno],lastks);
  1318.     }
  1319.     if (strsearch(lastks,savks) != lastks) lastks[0] = '\0'; else strcpy(lastks,savks);
  1320.     trecno = -1;
  1321.     if (ok) trecno = list_n_choose((byte)fno,(byte)kno,lastks,idxkey[fno][kno],findscrpos[fno][kno]);
  1322.     if (trecno == 0 && listAndAdd) trecno = add2CodeFile(fno);
  1323.     if ((trecno == 0) && specListAndAdd) trecno = specialadd(fno); /*NEW*/
  1324.     if (trecno > 0) {
  1325.       ok         = True;
  1326.       recno[fno] = trecno;
  1327.       link       = No_Link;
  1328.       getarec(fno);
  1329.       link       = Up_N_Down;
  1330.       strcopy(ks,makekey(lastks,fno,kno),0,strlen(ks));
  1331.     }
  1332.     else clear_rec(fno);
  1333.  
  1334.     ok          = tok;
  1335.     scrn_active = True;
  1336. ⁿIFDEF TABLESⁿ
  1337.     stabsiz = tabsize[filno];
  1338.     tabsize[filno] = 1;
  1339.     displayrec(filno,scrno);
  1340.     tabsize[filno] = stabsiz;
  1341. ⁿELSEDEFⁿ
  1342.     displayrec(filno,scrno);
  1343. ⁿENDDEFⁿ
  1344.   }
  1345.   fldnum--;
  1346.   listing = False;
  1347.   exitcode = Nul;
  1348.   strcpy(sout,LSC_BaseError);
  1349.   return(sout);
  1350. }
  1351.  
  1352. strptr listadd(strptr sout, int fno, int kno, keystr aKey)
  1353. {
  1354.    listAndAdd = True;
  1355.    list(sout, fno, kno, aKey);
  1356.    listAndAdd = False;
  1357.    return(sout);
  1358. }
  1359.  
  1360. strptr speclistadd(keystr sout, int fno, int kno, keystr ks)
  1361. {
  1362.   specListAndAdd = True;
  1363.   list(sout,fno,kno,ks);
  1364.   specListAndAdd = False;
  1365.   return(sout);
  1366. }
  1367.  
  1368.  
  1369.  
  1370. ⁿIFDEF ADJUSTⁿ
  1371. void afteradjdisp(int fno)
  1372. {
  1373.     int i;
  1374.  
  1375.     for (i = 1; i <= fno; i++) if (afteradj[fno][i] > 0) {
  1376.         (uw.wa[winforfile[i]])->disp = False;
  1377. ⁿIFDEF TABLESⁿ
  1378.         link = No_Link;
  1379.         displayrec(0,winforfile[i]);
  1380.         link = Up_N_Down;
  1381. ⁿELSEDEFⁿ
  1382.         displayrec(filno,winforfile[i]);
  1383. ⁿENDDEFⁿ
  1384.         afteradjdisp(i);
  1385.         hidewin(T_ON,uw.wa[winforfile[i]]);
  1386.     }
  1387. }
  1388. void updatekeys(int f)
  1389. {
  1390.     int i;
  1391.     keystr key;
  1392.  
  1393.   for (i=1; i <= maxkeyno; i++) {
  1394.     if (strcmp(getakey(key,f,i),tkeytab[i]) != 0) {
  1395. ⁿIFDEF MUSERⁿ
  1396.       must_secure_index(f,i,Lock);
  1397.       deletekey(idxkey[f][i],&recno[f],tkeytab[i]);
  1398.       addkey(idxkey[f][i],&recno[f],key);
  1399.       must_secure_index(f,1,UnLock);
  1400. ⁿELSEDEFⁿ
  1401.       deletekey(idxkey[f][i],&recno[f],tkeytab[i]);
  1402.       addkey(idxkey[f][i],&recno[f],key);
  1403. ⁿENDDEFⁿ
  1404.       if (!ok) dberrm(LSC_BadAdjust);
  1405.     }
  1406.   }
  1407. }
  1408.  
  1409. void adjust(int fno, uchar mode)
  1410. {
  1411.     int i;
  1412.  
  1413.     switch (fno) {
  1414.         ⁿadjustⁿ
  1415.     }
  1416. }
  1417. ⁿENDDEFⁿ
  1418.  
  1419. ⁿIFDEF LINKEDⁿ
  1420. void setlinkage(int fno)
  1421. {
  1422.     switch (fno) {
  1423.         ⁿsetlinkⁿ
  1424.     }
  1425. }
  1426. ⁿENDDEFⁿ
  1427.  
  1428. void remove_keys(int badkey)
  1429. {
  1430.     long recd;
  1431.     int keyno;
  1432.  
  1433.     for (keyno = 1; keyno <= (badkey-1); keyno++)
  1434.         if (strcmp(savkey[keyno],tkeytab[keyno]) != 0) {
  1435.             recd = recno[filno];
  1436. ⁿIFDEF MUSERⁿ
  1437.             must_secure_index(filno,keyno,Lock);
  1438.             deletekey(idxkey[filno][keyno],&recd,tkeytab[keyno]);
  1439.             must_secure_index(filno,keyno,UnLock);
  1440. ⁿELSEDEFⁿ
  1441.             deletekey(idxkey[filno][keyno],&recd,tkeytab[keyno]);
  1442. ⁿENDDEFⁿ
  1443.         }
  1444. }
  1445.  
  1446. ⁿIFDEF LINKEDⁿ
  1447. void putlink(int nummer)
  1448. {
  1449.     string tkey;
  1450.     long trecno;
  1451.     int tf;
  1452.  
  1453.     do {
  1454.         strcpy(key,savelnk[nummer]);
  1455.         strcpy(tkey,key);
  1456.         searchkey(idxkey[nummer][1],&recno[nummer],key);
  1457.         ok = (bool)(ok && (strsearch(key,tkey) == key));
  1458.         if (ok) {
  1459. ⁿIFDEF MUSERⁿ
  1460.             must_secure_rec(nummer,recno[nummer],1);
  1461. ⁿENDDEFⁿ
  1462.             link = No_Link;
  1463.             getarec(nummer);
  1464.             link = Up_N_Down;
  1465.             for (tf = 1; tf <= maxkeyno; tf++)
  1466.                 getakey(savkey[tf],nummer,tf);
  1467.             for (tf = 1; tf <= maxfilno; tf++)
  1468.                 if (linkback[tf].f == nummer) getlink(savelnk[tf],tf);
  1469.             setlinkage(nummer);
  1470.             putarec(nummer);
  1471.             for (tf = 1; tf <= maxkeyno; tf++) {
  1472.                 getakey(tkey,nummer,tf);
  1473.                 if (strcmp(savkey[tf],tkey) != 0) {
  1474. ⁿIFDEF MUSERⁿ
  1475.                     must_secure_index(nummer,tf,Lock);
  1476.                     deletekey(idxkey[nummer][tf],&recno[nummer],savkey[tf]);
  1477.                     addkey(idxkey[nummer][tf],&recno[nummer],tkey);
  1478.                     must_secure_index(nummer,tf,UnLock);
  1479. ⁿELSEDEFⁿ
  1480.                     deletekey(idxkey[nummer][tf],&recno[nummer],savkey[tf]);
  1481.                     addkey(idxkey[nummer][tf],&recno[nummer],tkey);
  1482. ⁿENDDEFⁿ
  1483.                 }
  1484.             }
  1485.             for (tf = 1; tf <= maxfilno; tf++)
  1486.                 if ((linkback[tf].f == nummer) &&       filinuse[tf] &&
  1487.                         (strcmp(savelnk[tf],getlink(tkey,tf)) != 0)) putlink(tf);
  1488. ⁿIFDEF MUSERⁿ
  1489.             tv = lock_datf(datf[nummer],recno[nummer],UnLock);
  1490. ⁿENDDEFⁿ
  1491.         }
  1492.     } while (ok);
  1493.     ok = True;
  1494. }
  1495. ⁿENDDEFⁿ
  1496.  
  1497. void edit_record(void)
  1498. {
  1499.     bool changedkey;
  1500.     int fno,tf,keyno;
  1501.     long trecno;
  1502.     keystr tk;
  1503.  
  1504. ⁿIFDEF MEMOSⁿ
  1505.    editmode = True;
  1506. ⁿENDDEFⁿ
  1507.  
  1508.    lastrecop = _Edit;
  1509.  
  1510. ⁿIFDEF MUSERⁿ
  1511.     ok = True;
  1512.    tf = filno;
  1513.    trecno = recno[filno];
  1514. ⁿIFDEF LINKEDⁿ
  1515.     if (linkback[filno].f > 0) traceback(filno); else {
  1516.         getakey(key,filno,primaryKno[filno]);
  1517.         findmulti(filno,&recno[filno],key);
  1518.     }
  1519. ⁿELSEDEFⁿ
  1520.     getakey(key,filno,primaryKno[filno]);
  1521.     findmulti(filno,&recno[filno],key);
  1522. ⁿENDDEFⁿ
  1523.     displayrec(filno,scrno);
  1524.     if ((filno != tf) || (recno[filno] != trecno) || !ok) {
  1525.         dspmsge(LSC_Warning,LSC_SomeoneDeleted,4.0);
  1526.         return;
  1527.     }
  1528.     if (lock_datf(datf[filno],recno[filno],Lock) != 0) {
  1529.         audible(Error);
  1530.         dspmsge(LSC_Warning,LSC_EditRecInUse,4.0);
  1531.     }
  1532.     else if (status_ok(filno)) {
  1533. ⁿELSEDEFⁿ
  1534.     if (status_ok(filno)) {
  1535. ⁿENDDEFⁿ
  1536.         getarec(filno);
  1537.         displayrec(filno,scrno);
  1538.         for (keyno = 1; keyno <= maxkeyno; keyno++)
  1539.              getakey(savkey[keyno],filno,keyno);
  1540. ⁿIFDEF LINKEDⁿ
  1541.         for (fno = 1; fno <= maxfilno; fno++) if (linkback[fno].f == filno)
  1542.             getlink(savelnk[fno],fno);
  1543. ⁿENDDEFⁿ
  1544. ⁿIFDEF ADJUSTⁿ
  1545.         adjust(filno,'D');
  1546. ⁿENDDEFⁿ
  1547.         edit_rec(0);
  1548.         changedkey = False;
  1549. ⁿIFDEF ADJUSTⁿ
  1550. ⁿIFDEF LINKEDⁿ
  1551. ⁿIFDEF MUSERⁿ
  1552.         for (fno = 1; fno <= maxfilno; fno++)
  1553.             if ((linkback[fno].f == filno) && filinuse[fno] && multiuser &&
  1554.                     (strcmp(savelnk[fno],getlink(tk,fno)) != 0)) {
  1555.                 dberrm(LSC_PreserveLink);
  1556.                 exitcode = QitKey;
  1557.             }
  1558. ⁿENDDEFⁿ
  1559. ⁿENDDEFⁿ
  1560. ⁿENDDEFⁿ
  1561.         if (exitcode != QitKey) {
  1562.             keyno = 1;
  1563.             while ((keyno <= maxkeyno) && (exitcode != QitKey)) {
  1564.                 getakey(tkeytab[keyno],filno,keyno);
  1565.                 if (strcmp(tkeytab[keyno],savkey[keyno]) == 0)
  1566.                     ok = True;
  1567.                 else {
  1568. ⁿIFDEF MUSERⁿ
  1569.                     must_secure_index(filno,keyno,Lock);
  1570.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  1571.                     must_secure_index(filno,keyno,UnLock);
  1572. ⁿELSEDEFⁿ
  1573.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  1574. ⁿENDDEFⁿ
  1575.                     if (!ok) {
  1576.                         remove_keys(keyno);
  1577.                         audible(Error);
  1578.                         dspmsge(LSC_BaseError,LSC_KeyExists,4.0);
  1579.                         edit_rec(keyfld[filno][keyno]);
  1580.                         keyno = 0;
  1581.                     }
  1582.                 }
  1583.                 keyno++;
  1584.             }
  1585.             if (exitcode != QitKey) {
  1586.                 for (keyno = 1; keyno <= maxkeyno; keyno++)
  1587.                     if (strcmp(tkeytab[keyno],savkey[keyno]) != 0) {
  1588.                         changedkey = True;
  1589.                         strcpy(tk,tkeytab[keyno]);
  1590.                         strcpy(tkeytab[keyno],savkey[keyno]);
  1591.                         strcpy(savkey[keyno],tk);
  1592.                     }
  1593.                 remove_keys(maxkeyno+1);
  1594.                 putarec(filno);
  1595. ⁿIFDEF LINKEDⁿ
  1596.                 for (fno = 1; fno <= maxfilno; fno++)
  1597.                     if ((linkback[fno].f == filno) &&
  1598.                             (linkback[fno].t == _Unique) &&
  1599.                             filinuse[fno] &&
  1600.                             (strcmp(savelnk[fno],getlink(tk,fno)) != 0)) putlink(fno);
  1601. ⁿENDDEFⁿ
  1602.             }
  1603.             else ok = True;
  1604.         }
  1605.         getarec(filno);
  1606. ⁿIFDEF ADJUSTⁿ
  1607.         adjust(filno,'A');
  1608.         afteradjdisp(filno);
  1609. ⁿENDDEFⁿ
  1610. ⁿIFDEF TABLESⁿ
  1611.         if ((tabsize[filno] > 1) && changedkey) {
  1612.             getakey(savkey[1],filno,primaryKno[filno]);
  1613.             findmulti(filno,&recno[filno],savkey[1]);
  1614.             align_tab(filno);
  1615.         }
  1616. ⁿENDDEFⁿ
  1617.         displayrec(filno,scrno);
  1618. ⁿIFDEF MUSERⁿ
  1619.         tv = lock_datf(datf[filno],recno[filno],UnLock);
  1620. ⁿENDDEFⁿ
  1621.  
  1622.    lastrecop = Nul;
  1623.  
  1624. ⁿIFDEF MEMOSⁿ
  1625.    editmode = False;
  1626. ⁿENDDEFⁿ
  1627.     }
  1628. }
  1629.  
  1630. ⁿIFDEF MEMOSⁿ
  1631. void deletememos(void *fb, void *buf, int fno)
  1632. {
  1633.     word w;
  1634.     long mrec,trec;
  1635.     genbuf sbuf;
  1636.     fldblk *fblk;
  1637.     fldtyp *fld;
  1638.     byteptr buffer;
  1639.  
  1640.     fblk = (fldblk *) fb;
  1641.     buffer = (byteptr) buf;
  1642.     memmove(&sbuf[1],buf,fblk->dsz);
  1643.     w = 0;
  1644.     do {
  1645.         fld = &(*fblk->farr)[w];
  1646.         if (fld->typ == _Memo) {
  1647.             memmove(&mrec,fld->faddr,4);
  1648.             while (mrec != 0) {
  1649.                 getrec(datf[fno],mrec,buf);
  1650.                 memmove(&trec,&buffer[(fblk->dsz-3)-1],4);
  1651.                 deleterec(datf[fno],mrec);
  1652.                 mrec = trec;
  1653.             }
  1654.             memmove(buf,&sbuf[1],fblk->dsz);
  1655.         }
  1656.         w++;
  1657.     } while (w < fblk->numf);
  1658. }
  1659. ⁿENDDEFⁿ
  1660.  
  1661. ⁿIFDEF MUSERⁿ
  1662. ⁿIFDEF LINKEDⁿ
  1663. bool lock_linked(int fno, int lck)
  1664. {
  1665.     bool savok, tb;
  1666.     int i, keyno;
  1667.     uchar ans[2];
  1668.     uchar tpic[2];
  1669.     keystr tkey, tkey2;
  1670.  
  1671.    strcpy(ans, " ");
  1672.    strcpy(tpic, " ");
  1673.     tb      = True;
  1674.    ans[0]  = _Retry;
  1675.    tpic[0] = Pic_U;
  1676.     if (fno != filno) {        /* "filno" Already Locked By Delete_Record */
  1677.         do {
  1678.             tv = lock_datf(datf[fno],recno[fno],lck);
  1679.             if (tv == -1)
  1680.                 dbgetstr(ans,_Ch,LSC_LinkedDelRecInUse,ans,tpic,"",chkabortretry,nohelp);
  1681.         } while ((tv != 0) && (ans[0] != _Abort));
  1682.     }
  1683.     tb = (ans[0] == _Retry);
  1684.     if (tb) {
  1685.         link = No_Link;
  1686.         getarec(fno);
  1687.         link = Up_N_Down;
  1688.         for (i = 1; i <= maxfilno; i++) {
  1689.             if ((linkback[i].t == _Unique) && (linkback[i].f == fno)) {
  1690.                 if (filinuse[i]) {
  1691.                     getlink(tkey,i);  strcpy(tkey2,tkey);
  1692.                     searchkey(idxkey[i][1],&recno[i],tkey2);
  1693.                     savok = (bool)(ok && (strsearch(tkey2,tkey) == tkey2));
  1694.                     while (savok && tb) {
  1695.                         tb = lock_linked(i,lck);
  1696.                         nextkey(idxkey[i][1],&recno[i],tkey2);
  1697.                         savok = (bool)(ok && (strsearch(tkey2,tkey) == tkey2));
  1698.                     }
  1699.                     ok = True;  /* Restore OK to True */
  1700.                 }
  1701.             }
  1702.         }
  1703.     }
  1704.     return(tb);
  1705. }
  1706. ⁿENDDEFⁿ
  1707. ⁿENDDEFⁿ
  1708.  
  1709. void delarec(int fno)
  1710. {
  1711.     string tkey,tkey2;
  1712.     bool savok;
  1713.     int i,keyno;
  1714.     long delrecno;
  1715.  
  1716. ⁿIFDEF MUSERⁿ
  1717.   lockByDel[fno] = True;
  1718. ⁿENDDEFⁿ
  1719. ⁿIFDEF LINKEDⁿ
  1720. ⁿIFDEF MUSERⁿ
  1721.     if (fno == filno) {
  1722.         savok = lock_linked(fno,Lock);
  1723.         if (!savok) {
  1724.             savok = lock_linked(fno,UnLock); nextrec = recno[fno]; return;
  1725.         }
  1726.     }
  1727. ⁿENDDEFⁿ
  1728.     getarec(fno);
  1729.     for (i = 1; i <= maxfilno; i++) {
  1730.         if ((linkback[i].t == _Unique) && (linkback[i].f == (byte)fno)) {
  1731.             if (filinuse[i]) {
  1732.                 getlink(tkey,i);
  1733.                 strcpy(tkey2,tkey);
  1734.                 do {
  1735.                     searchkey(idxkey[i][1],&recno[i],tkey2);
  1736.                     savok = (bool)(ok && (strsearch(tkey2,tkey) == tkey2));
  1737.                     if (savok) delarec(i);
  1738.                 } while (savok);
  1739.             }
  1740.         }
  1741.     }
  1742. ⁿELSEDEFⁿ
  1743.     getarec(fno);
  1744. ⁿENDDEFⁿ
  1745.     delrecno = recno[fno];
  1746. ⁿIFDEF MUSERⁿ
  1747.     if (fno != filno) must_secure_rec(fno,0L,2);
  1748. ⁿENDDEFⁿ
  1749. ⁿIFDEF MEMOSⁿ
  1750.     switch (fno) {
  1751.         ⁿDELMEMOSⁿ
  1752.     }
  1753. ⁿENDDEFⁿ
  1754.     deleterec(datf[fno], delrecno);
  1755.     for (keyno = 1; keyno <= maxkeyno; keyno++) {
  1756.         if (keylen[fno][keyno] > 0) {
  1757.             delrecno = recno[fno];
  1758.             getakey(tkey,fno,keyno);
  1759. ⁿIFDEF MUSERⁿ
  1760.             must_secure_index(fno,keyno,Lock);
  1761.             deletekey(idxkey[fno][keyno],&delrecno,tkey);
  1762.             must_secure_index(fno,keyno,UnLock);
  1763. ⁿELSEDEFⁿ
  1764.             deletekey(idxkey[fno][keyno],&delrecno,tkey);
  1765. ⁿENDDEFⁿ
  1766.         }
  1767.     }
  1768. ⁿIFDEF ADJUSTⁿ
  1769.     adjust(fno,'D');
  1770. ⁿENDDEFⁿ
  1771. ⁿIFDEF MUSERⁿ
  1772.     if (fno != filno) {
  1773.         tv = lock_datf(datf[fno],recno[fno],UnLock);
  1774.         tv = lock_datf(datf[fno],0L,UnLock);
  1775.     }
  1776. ⁿENDDEFⁿ
  1777. ⁿIFDEF MUSERⁿ
  1778.   lockByDel[fno] = False;
  1779. ⁿENDDEFⁿ
  1780. }
  1781.  
  1782. void delete_record(void)
  1783. {
  1784.     byte i,ch;
  1785.     long trecno;
  1786.     keystr nxtkey;
  1787.     bool tok,child;
  1788.     int tf;
  1789.     string msg;
  1790.  
  1791.    lastrecop = _Delete;
  1792. ⁿIFDEF MUSERⁿ
  1793.     ok = True;
  1794.     tf = filno;
  1795.     trecno = recno[filno];
  1796. ⁿIFDEF LINKEDⁿ
  1797.     if (linkback[filno].f > 0) traceback(filno); else {
  1798.         getakey(key,filno,primaryKno[filno]);
  1799.         findmulti(filno,&recno[filno],key);
  1800.     }
  1801. ⁿELSEDEFⁿ
  1802.     getakey(key,filno,primaryKno[filno]);
  1803.     findmulti(filno,&recno[filno],key);
  1804. ⁿENDDEFⁿ
  1805.     displayrec(filno,scrno);
  1806.     if ((filno != tf) || (recno[filno] != trecno) || !ok) {
  1807.         dspmsge(LSC_Warning,LSC_SomeoneDeleted,4.0);
  1808.         return;
  1809.     }
  1810.     if (lock_datf(datf[filno],0L,Lock) != 0) {
  1811.         audible(Error);
  1812.         dspmsge(LSC_Warning,LSC_StatusUnavail,4.0);
  1813.     }
  1814.     else if (lock_datf(datf[filno],recno[filno],Lock) != 0) {
  1815.         audible(Error);
  1816.         dspmsge(LSC_Warning,LSC_DelRecInUse,4.0);
  1817.         tv = lock_datf(datf[filno],0L,UnLock);
  1818.     }
  1819.     else if (status_ok(filno)) {
  1820. ⁿELSEDEFⁿ
  1821.     if (status_ok(filno)) {
  1822. ⁿENDDEFⁿ
  1823.         getarec(filno);
  1824.         displayrec(filno,scrno);
  1825. ⁿIFDEF LINKEDⁿ
  1826.         child = False;
  1827.         for (i = 1; i <= maxfilno; i++)
  1828.             child = (bool)(child || ((linkback[i].f == (byte)filno) && (filinuse[i])));
  1829.         strcpy(msg,(child) ? LSC_DelLinkedRec : LSC_ConfirmDelRec);
  1830. ⁿELSEDEFⁿ
  1831.         strcpy(msg, LSC_ConfirmDelRec);
  1832. ⁿENDDEFⁿ
  1833.         do {
  1834.             dspmsge(LSC_Warning,msg,0.0);
  1835.             ch = upperch(getkey());
  1836.         } while ((ch !=_YES) && (ch != QitKey));
  1837.         if (ch == _YES) {
  1838.             trecno = recno[filno];
  1839.             prevkey(primaryIdxP[filno],&recno[filno],key);               /*MOD PK*/
  1840.             if (ok) {
  1841.                 strcpy(nxtkey,key);
  1842.                 nextrec = recno[filno];
  1843.             }
  1844.             tok = ok;
  1845.             nextkey(primaryIdxP[filno],&recno[filno],key);               /*MOD PK*/
  1846.             if (recno[filno] != trecno) {
  1847.                 audible(Error);
  1848.                 dspmsge(LSC_BaseError,LSC_CorruptIndex,4.0);
  1849.                 getarec(filno);
  1850.                 displayrec(filno,scrno);
  1851.             }
  1852.             else {
  1853.                 ok = True;
  1854.         message(NULL, LSC_Deleting);
  1855.                 delarec(filno);
  1856.         message(NULL, "");
  1857. ⁿIFDEF ADJUSTⁿ
  1858.                 afteradjdisp(filno);
  1859. ⁿENDDEFⁿ
  1860.                 if (tok) {
  1861.                     recno[filno] = nextrec;
  1862.                     findmulti(filno,&recno[filno],nxtkey);
  1863.                     if (ok) {
  1864.                         getarec(filno);
  1865. ⁿIFDEF TABLESⁿ
  1866.                         if (tabsize[filno] != 1) align_tab(filno);
  1867. ⁿENDDEFⁿ
  1868.                         if (status_ok(filno)) displayrec(filno,scrno); else top_record();
  1869.                     }
  1870.                     else top_record();
  1871.                 }
  1872.                 else top_record();
  1873.             }
  1874.         }
  1875. ⁿIFDEF MUSERⁿ
  1876.         tv = lock_datf(datf[filno],trecno,UnLock);
  1877.         tv = lock_datf(datf[filno],0L,UnLock);
  1878. ⁿENDDEFⁿ
  1879.     }
  1880.     else audible(Warning);
  1881. }
  1882.  
  1883. strptr autoinc(keystr sout, int kno)
  1884. {
  1885.    float tl = 1;                                      /* SN 3.5 */
  1886.    char  tempString1[10],                             /* SN 3.5 */
  1887.     tempString2[10],                                   /* SN 3.5 */
  1888.     tempString3[10],                                   /* SN 3.5 */
  1889.     tempString4[10],                                   /* SN 3.5 */
  1890.     tempString5[10],                                   /* SN 3.5 */
  1891.     fileName[20];                                      /* SN 3.5 */
  1892.  
  1893.     clearkey(idxkey[filno][kno]);
  1894.     prevkey(idxkey[filno][kno],&recno[filno],key);
  1895.  
  1896.     if (!ok) strcpy(sout,"1");
  1897.     else     strip(sout,fstr(sout,valu(key)+1,11,0));
  1898.  
  1899. ⁿIFDEF MUSERⁿ
  1900.    if (multiuser) {                                         /* SN 3.5 */
  1901.       *fileName    = *tempString1 = *tempString2 = Nul;
  1902.       *tempString3 = *tempString4 = *tempString5 = Nul;
  1903.       istr(tempString4, filno, 2);
  1904.       istr(tempString5, kno,   2);
  1905.       strip(tempString2, tempString4);
  1906.       strip(tempString3, tempString5);
  1907.       strcopy(tempString1, "ⁿMODNAMEⁿ", 0, 5);
  1908.       strconcat(fileName, "~", tempString1, tempString2, tempString3, NULL);
  1909.       tl = txtinc(fileName, tl);
  1910.       fstr(sout, tl, 11, 0);
  1911.    }
  1912. ⁿENDDEFⁿ
  1913.     return (strip(tempString1, sout));
  1914. }
  1915.  
  1916. void addarec(void)
  1917. {
  1918.     switch (filno) {
  1919.         ⁿADDRECⁿ
  1920.     }
  1921. }
  1922.  
  1923. void add_record(char func)
  1924. {
  1925. ⁿIFDEF TABLESⁿ
  1926.     byte stabsiz,stabidx;
  1927. ⁿENDDEFⁿ
  1928.     int fno;
  1929.     long savr,recd;
  1930.     int tf,keyno;
  1931.     bool rav;
  1932.     string tts;
  1933.  
  1934.    lastrecop = func;
  1935.     rav              = True;
  1936. ⁿIFDEF LINKEDⁿ
  1937. ⁿIFDEF MUSERⁿ
  1938.     if (linkback[filno].f > 0) {
  1939.         tf = filno;
  1940.         traceback(filno);
  1941.         displayrec(filno,scrno);
  1942.         if (filno != tf) {
  1943.             dspmsge(LSC_Warning,LSC_SomeoneDeleted,4.0);
  1944.             return;
  1945.         }
  1946.     }
  1947. ⁿENDDEFⁿ
  1948.     if (linkback[filno].f > 0) rav = recavail[linkback[filno].f];
  1949. ⁿENDDEFⁿ
  1950.     if ((usedrecs(datf[filno]) >= maxrec[filno]) || !rav) {
  1951.         if (rav) dspmsge("",LSC_MaxRecsReached,4.0);
  1952.         else     dspmsge("",LSC_NoParentRec,4.0);
  1953.     }
  1954.     else {
  1955.         if (ok) savr = recno[filno]; else savr = 0;
  1956.         scrn_active = False;
  1957.         cleartop = (bool)(func == 'A');
  1958.         clear_rec(filno);
  1959.         scrn_active = True;
  1960. ⁿIFDEF MEMOSⁿ
  1961.         if (!cleartop)
  1962.             switch (filno) {
  1963.                 ⁿCLEARMEMOⁿ
  1964.             }
  1965. ⁿENDDEFⁿ
  1966.         cleartop = True;
  1967.         ⁿSETFIELDⁿ
  1968. ⁿIFDEF TABLESⁿ
  1969.         stabsiz = 1;
  1970.         if (tabsize[filno] > 1) {
  1971.             stabidx = tabidx[filno];
  1972.             if (tabidx[filno] == tabsize[filno])
  1973.                 tabidx[filno] = 1;
  1974.             else
  1975.                 tabidx[filno] = tabused[filno]+1;
  1976.             stabsiz = tabsize[filno];
  1977.             tabsize[filno] = 1;
  1978.         }
  1979.         leaveclear = True;
  1980. ⁿENDDEFⁿ
  1981.         displayrec(filno,scrno);
  1982.         edit_rec(0);
  1983.         if (exitcode != QitKey) {
  1984. ⁿIFDEF MUSERⁿ
  1985.             must_secure_rec(filno,0L,2);
  1986.             addarec();
  1987.             tv = lock_datf(datf[filno],recno[filno],Lock);
  1988.             tv = lock_datf(datf[filno],0L,UnLock);
  1989. ⁿELSEDEFⁿ
  1990.             addarec();
  1991. ⁿENDDEFⁿ
  1992.             for (keyno = 1; keyno <= maxkeyno; keyno++) savkey[keyno][0] = '\0';
  1993.             keyno = 1;
  1994.             ok      = True;
  1995.             while ((keyno <= maxkeyno) && (exitcode != QitKey)) {
  1996.                 if (keylen[filno][keyno] > 0) {
  1997.                     getakey(tkeytab[keyno],filno,keyno);
  1998. ⁿIFDEF MUSERⁿ
  1999.                     must_secure_index(filno,keyno,Lock);
  2000.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  2001.                     must_secure_index(filno,keyno,UnLock);
  2002. ⁿELSEDEFⁿ
  2003.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  2004. ⁿENDDEFⁿ
  2005.                     if (!ok) {
  2006.                         remove_keys(keyno);
  2007.                         audible(Error);
  2008.                         dspmsge(LSC_BaseError,LSC_KeyExists,4.0);
  2009.                         edit_rec(keyfld[filno][keyno]);
  2010.                         if (exitcode == QitKey) {
  2011.                             recd = recno[filno];
  2012. ⁿIFDEF MUSERⁿ
  2013.                             must_secure_rec(filno,0L,2);
  2014.                             deleterec(datf[filno],recd);
  2015.                             tv = lock_datf(datf[filno],0L,UnLock);
  2016. ⁿELSEDEFⁿ
  2017.                             deleterec(datf[filno],recd);
  2018. ⁿENDDEFⁿ
  2019.                             recno[filno] = savr;
  2020.                         }
  2021.                         else {
  2022.                             keyno = 0;
  2023.                             putarec(filno);
  2024.                         }
  2025.                     }
  2026.                 }
  2027.                 keyno++;
  2028.             }
  2029. ⁿIFDEF ADJUSTⁿ
  2030.             if (exitcode != QitKey) {
  2031.                 adjust(filno,'A');
  2032.                 afteradjdisp(filno);
  2033.             }
  2034. ⁿENDDEFⁿ
  2035. ⁿIFDEF MUSERⁿ
  2036.             tv = lock_datf(datf[filno],recno[filno],UnLock);
  2037. ⁿENDDEFⁿ
  2038.         }
  2039.         else recno[filno] = savr;
  2040.         if (exitcode == QitKey) {
  2041. ⁿIFDEF TABLESⁿ
  2042.             if (stabsiz > 1) tabidx[filno] = stabidx;
  2043. ⁿENDDEFⁿ
  2044. ⁿIFDEF MEMOSⁿ
  2045. ⁿIFDEF MUSERⁿ
  2046.             must_secure_rec(filno,0L,2);
  2047. ⁿENDDEFⁿ
  2048.             fno = filno;
  2049.             switch (fno) {
  2050.                 ⁿDELMEMOSⁿ
  2051.             }
  2052. ⁿIFDEF MUSERⁿ
  2053.             tv = lock_datf(datf[filno],0L,UnLock);
  2054. ⁿENDDEFⁿ
  2055. ⁿENDDEFⁿ
  2056.         }
  2057. ⁿIFDEF TABLESⁿ
  2058.         if (stabsiz > 1) tabsize[filno] = stabsiz;
  2059.         leaveclear = False;
  2060. ⁿENDDEFⁿ
  2061.         ok = (bool)(ok || (savr > 0));
  2062.         getarec(filno);
  2063. ⁿIFDEF TABLESⁿ
  2064.         if ((exitcode != QitKey) && (tabsize[filno] > 1)) {
  2065.             getakey(skey,filno,primaryKno[filno]);
  2066.             findmulti(filno,&recno[filno],skey);
  2067.             align_tab(filno);
  2068.         }
  2069. ⁿENDDEFⁿ
  2070.         displayrec(filno,scrno);
  2071.     }
  2072.    lastrecop = Nul;
  2073. }
  2074.  
  2075. long specialadd(int fno)
  2076. {
  2077.   bool saveDisp;
  2078.   int saveFilno, saveScrno, saveFldNum;
  2079.   editGlobalVars saveEDT;
  2080.  
  2081.   saveFilno = filno;
  2082.   saveScrno = scrno;
  2083.   saveFldNum = fldnum;
  2084.   memmove(&saveEDT,&edt,sizeof(editGlobalVars));
  2085.   filno = fno;
  2086.   scrno = winforfile[filno];
  2087.   saveDisp = uw.wa[scrno]->disp;
  2088.   selectwin(uw.wa[scrno]);
  2089.   if (!saveDisp) hidewin(T_ON,uw.wa[scrno]);
  2090.   add_record(_Add);
  2091.   if (!saveDisp) hidewin(T_OFF,uw.wa[scrno]);
  2092.   exitcode = Nul;
  2093.   memmove(&edt,&saveEDT,sizeof(editGlobalVars));
  2094.   fldnum = saveFldNum;
  2095.   scrno = saveScrno;
  2096.   for (filno=1;filno<=16;filno++){ if (uw.wa[filno] != NULL) selectwin(uw.wa[filno]);}
  2097.   filno = saveFilno;
  2098.   return(recno[fno]);
  2099. }
  2100.  
  2101.  
  2102.  
  2103. void initialize(void)
  2104. {
  2105.    ⁿKEYFIELDⁿ
  2106.    command    = Cmd_No_Command;
  2107.    deltas     = def1.deltat;
  2108.     keynum     = 1;
  2109.     scrno      = 1;
  2110.     _trace     = 0;
  2111.     menuanchor = 0;
  2112.     link       = Up_N_Down;
  2113.     listing    = False;
  2114.    listAndAdd = False;
  2115. ⁿIFDEF TABLESⁿ
  2116.     leaveclear = False;
  2117.     switchtab = False;
  2118. ⁿENDDEFⁿ
  2119.     scrn_active = False;
  2120.     cleartop = True;
  2121.     for (filno = 1; filno <= maxfilno; filno++)
  2122.     {
  2123.     primaryKno[filno] = 1;                                         /*MOD PK*/
  2124.      primaryIdxP[filno] = idxkey[filno][1];                         /*MOD PK*/
  2125.      fileCanWalk[filno] = True;                                     /*MOD CH*/
  2126. ⁿIFDEF LINKEDⁿ
  2127.      fileCanWalk[filno] = linkback[filno].f == 0;                   /*MOD PK*/
  2128. ⁿENDDEFⁿ
  2129.         recno[filno] = 0;
  2130.  
  2131. ⁿIFDEF MUSERⁿ
  2132.     lockByDel[filno] = False;
  2133. ⁿENDDEFⁿ
  2134. ⁿIFDEF TABLESⁿ
  2135.         tabrecno[filno] = 0;
  2136. ⁿENDDEFⁿ
  2137. ⁿIFDEF LINKEDⁿ
  2138.         clear_rec(filno);
  2139. ⁿELSEDEFⁿ
  2140.         top_record();
  2141. ⁿENDDEFⁿ
  2142.         recavail[filno] = (bool)(usedrecs(datf[filno]) > 0);
  2143. ⁿIFDEF TABLESⁿ
  2144.         tabidx[filno] = 1; tabused[filno] = 0;
  2145. ⁿENDDEFⁿ
  2146.     }
  2147. ⁿIFDEF LINKEDⁿ
  2148.     for (filno = 1; filno <= maxfilno; filno++) if (linkback[filno].f == 0) top_record();
  2149. ⁿENDDEFⁿ
  2150.     scrn_active = True;
  2151.     filno = 1;
  2152.    specListAndAdd = False;
  2153.  
  2154.    /* to use specialist add change the 1 in the following line to the
  2155.    filenumber that you wish to use the scecial listadd on.
  2156.    */
  2157.  
  2158. /*   filinuse[1] = False; */
  2159.  
  2160.  
  2161.  
  2162. }
  2163.  
  2164. bool custom_key(int scr, int fno, int *fld, uchar *key)
  2165. {
  2166.     bool tb;
  2167.  
  2168.     ⁿcodedispⁿ
  2169.     return(False);
  2170. }
  2171.  
  2172. void on_error(void)
  2173. {
  2174.     closefiles();
  2175. }
  2176.  
  2177. void swapmenu(void)
  2178. {
  2179.     bool savdisp;
  2180.     byte ni,tl,tw,tlen;
  2181.     itmptr titm;
  2182.     mnuptr m;
  2183.  
  2184.     savdisp = (bool)((dm.curmnu->winp != NULL) && dm.curmnu->winp->disp);
  2185.     if (savdisp) zapmnu(&dm,dm.curmnu);
  2186.     m = dm.curmnu;
  2187.     m->mtyp = (byte)((m->mtyp == Vert) ? 2 : Vert);
  2188.     tw = 1; ni = 0; tl = 0;
  2189.     titm = m->fitm;
  2190.     do {
  2191.         ni++; tl += m->mtyp;
  2192.         if (m->mtyp == Vert) { titm->ix = 2; titm->iy = ni; }
  2193.         else { titm->ix = tl; titm->iy = 1; }
  2194.         tlen = (byte)strlen(titm->prompt); tl += tlen;
  2195.         if (tlen > tw) tw = tlen;
  2196.         titm = titm->nitm;
  2197.     } while (titm != m->fitm);
  2198.     if (m->mtyp == Vert) { m->widm = tw+2; m->hgtm = ni; }
  2199.     else { m->widm = tl+m->mtyp-2; m->hgtm = 1; }
  2200.     if (m->mtyp != Vert) {
  2201.         m->ym = (m->xm == 2) ? 1 : scrhgt;
  2202.         m->xm = 1; m->mbchrs[0] = '\0';
  2203.     }
  2204.     else {
  2205.         if (m->ym == 1) { m->ym = 2; m->xm = scrwid-m->widm; }
  2206.         else { m->ym = scrhgt-m->hgtm; m->xm = 2; }
  2207.         m->mbchrs[0] = '─';
  2208.     }
  2209.     if (savdisp) dspmnu(&dm,dm.curmnu);
  2210.     menuanchor = (menuanchor+1) % 4;
  2211. }
  2212.  
  2213. void changeto(pathstr newpath, int *res)
  2214. {
  2215.     *res = (changedir(newpath)) ? 0 : 1;
  2216.     if (*res == 0) {
  2217.         getcurrentdir(datapath,0);
  2218.         pathSwap = True;
  2219.     }
  2220. }
  2221.  
  2222. void newload(mnufrec *m, pathstr newmenu)
  2223. {
  2224.     int i;
  2225.     pathstr newnam;
  2226.  
  2227.     strcpy(newnam,newmenu);
  2228.     svm = smc;
  2229.     smc = db_malloc(sizeof(savmtyp));
  2230.     smc->savprv = svm;
  2231.     strcpy(smc->savnam,m->mnufnam);
  2232.     smc->savno = m->curmnu->mno;
  2233.     strcpy(smc->savprompt,m->curitm->prompt);
  2234.     if (dm.curitm->selpath[0] != '\0') {
  2235.         getcurrentdir(smc->savpath,0);
  2236.         changeto(dm.curitm->selpath,&i);
  2237.     }
  2238.     else {
  2239.         i = 0;
  2240.         smc->savpath[0] = '\0';
  2241.     }
  2242.     if (i == 0) {
  2243.         disposemnus(&dm);
  2244.         strcpy(dm.mnufnam,newnam);
  2245.         initmnu(&dm,0,0,OnDisk);
  2246.         dispallwin();
  2247.         if (dm.curmnu == NULL) {
  2248.             if (smc->savpath[0] != '\0')
  2249.                 changeto(smc->savpath,&i);
  2250.                 strcpy(dm.mnufnam,smc->savnam);
  2251.                 initmnu(&dm,0,0,OnDisk);
  2252.                 dispallwin();
  2253.                 jumptomnu(&dm,smc->savno);
  2254.                 do
  2255.                     dm.curitm = dm.curitm->nitm;
  2256.                 while ((strcmp(smc->savnam,dm.curitm->prompt) != 0) &&
  2257.                                 (dm.curitm != dm.curmnu->fitm));
  2258.                 db_free(smc);
  2259.                 smc = svm;
  2260.             }
  2261.             else {
  2262.                 dspmnu(&dm,dm.curmnu);
  2263.             }
  2264.         }
  2265.         else {
  2266.             db_free(smc);
  2267.             smc = svm;
  2268.             doserr(3,dm.curitm->selpath);
  2269.         }
  2270.     pathSwap = True;
  2271. }
  2272.  
  2273. void setcommand(byte c_num)
  2274. {
  2275.     switch(c_num) {
  2276.       case 1 :  command = Cmd_Next_Record;    break;
  2277.       case 2 :  command = Cmd_Prev_Record;    break;
  2278.       case 3 :  command = Cmd_Find_Record;    break;
  2279.       case 4 :  command = Cmd_Top_Record;     break;
  2280.       case 5 :  command = Cmd_Last_Record;    break;
  2281.       case 6 :  command = Cmd_Edit_Record;    break;
  2282.       case 7 :  command = Cmd_Add_Record;     break;
  2283.       case 8 :  command = Cmd_Copy_Record;    break;
  2284.       case 9 :  command = Cmd_Delete_Record;  break;
  2285.       case 10 : command = Cmd_Next_File;      break;
  2286.       case 11 : command = Cmd_Prev_File;      break;
  2287.       case 12 : command = Cmd_Swap_Menu;      break;
  2288.    }
  2289. }
  2290.  
  2291. void do_proc(int procno, mnufrec *m)
  2292. {
  2293.    setcommand(procno);
  2294.    hidewin(T_OFF,dm.curmnu->winp);
  2295.     switch (procno) {
  2296.         case 1 : next_record(_Next); break;
  2297.         case 2 : next_record(_Prev); break;
  2298.         case 3 : find_record(); break;
  2299.         case 4 : if (status_ok(filno)) top_record(); else audible(Warning); break;
  2300.         case 5 : last_record(); break;
  2301.         case 6 : if (status_ok(filno)) {
  2302.             edit_record();
  2303.             getakey(key,filno,primaryKno[filno]);
  2304.             findmulti(filno,&recno[filno],key);
  2305.             if (!ok) top_record();
  2306.         }
  2307.         else audible(Warning); break;
  2308.         case 7 :
  2309.             add_record('A');
  2310.             getakey(key,filno,primaryKno[filno]);
  2311.             findmulti(filno,&recno[filno],key);
  2312.             if (!ok) top_record();
  2313.         break;
  2314.         case 8 : if (status_ok(filno)) {
  2315.             add_record('C');
  2316.             getakey(key,filno,primaryKno[filno]);
  2317.             findmulti(filno,&recno[filno],key);
  2318.             if (!ok) top_record();
  2319.         }
  2320.         else audible(Warning); break;
  2321.         case 9 : delete_record(); break;
  2322.         case 10: switch_file('+'); break;
  2323.         case 11: switch_file('-'); break;
  2324.         case 12: setdeltas(); break;
  2325.         case 13: swapmenu(); break;
  2326. /***************************************************************************
  2327. * [DG] 09/11/92 -- Added cases 101-116, which will switch instantly to     *
  2328. *                  files 1-16, by subtracting 100 from the case number.    *
  2329. *                  If the file number is larger than the maximum defined   *
  2330. *                  file, we switch to the highest valid file.              *
  2331. ***************************************************************************/
  2332.       case 101:
  2333.       case 102:
  2334.       case 103:
  2335.       case 104:
  2336.       case 105:
  2337.       case 106:
  2338.       case 107:
  2339.       case 108:
  2340.       case 109:
  2341.       case 110:
  2342.       case 111:
  2343.       case 112:
  2344.       case 113:
  2345.       case 114:
  2346.       case 115:
  2347.       case 116: filno = (procno - 100);
  2348.         if (filno > maxfilno)  filno = maxfilno;
  2349.         switch_file(' ');
  2350.         break;
  2351. /***********************/ /* [DG] End Modification */ /*******************/
  2352.     }
  2353.    hidewin(T_ON,dm.curmnu->winp);
  2354.    dispwindow(dm.curmnu->winp);
  2355. }
  2356.  
  2357. void do_ctl(mnufrec *m, itmptr itm)
  2358. {
  2359.     string ts;
  2360.     uchar yes[2],tpic[2];
  2361.  
  2362.     if ((m->curmnu != NULL) && (itm != NULL)) {
  2363.         switch (itm->seltyp) {
  2364.             case _Proc : do_proc((int) ival(itm->selact),m); break;
  2365.             case _Menu :
  2366.                 if ((ival(itm->selact) > 0) && (m->mat[(int) ival(itm->selact)-1] != NULL)) {
  2367.                     if (m->mat[(int) ival(itm->selact)-1]->winp != NULL)
  2368.                         jumptomnu(m,(byte) ival(itm->selact));
  2369.                     else {
  2370.                         m->mat[(int) ival(itm->selact)-1]->pmnu = m->curmnu->mno;
  2371.                         m->curmnu = m->mat[(int) ival(itm->selact)-1];
  2372.                         dspmnu(m,m->curmnu);
  2373.                         m->curitm = m->curmnu->litm;
  2374.                         m->level = 0;
  2375.                     }
  2376.                 }
  2377.             break;
  2378.             case _Quit :
  2379.                 dbgetstr(ts,_Ch,LSC_QuitDataBase,chstr(yes,_YES),chstr(tpic,Pic_U),"",chkyesno,nohelp);
  2380.                 quit = (bool)((ts[0] == _YES) && (exitcode != QitKey));
  2381.             break;
  2382.         }
  2383.     }
  2384. }
  2385.  
  2386. bool initdbm(void)
  2387. {
  2388.     strcpy(dm.mnufnam,localmenu);
  2389.     initmnu(&dm,0,0,OnDisk);
  2390.     return (bool)(dm.curmnu != NULL);
  2391. }
  2392.  
  2393. void datenpath(void)
  2394. {
  2395.     string ts;
  2396.  
  2397.     if (uw.bgw != NULL) {
  2398.         if (mdate.x != 0)
  2399.             if (mdate.m == 0)
  2400.                 writewxy(datum(ts,sysdate(ts)),0,mdate.x,mdate.y,uw.bgw);
  2401.             else
  2402.                 writewxy(slash(ts,sysdate(ts)),0,mdate.x,mdate.y,uw.bgw);
  2403.         if (mpath.x != 0) {
  2404.             strcpy(ts,datapath);
  2405.             if (strlen(ts) == 3) strcat(ts,applname);
  2406.             else { strcat(ts,"\\"); strcat(ts,applname); }
  2407.             writewxy(ts,0,mpath.x,mpath.y,uw.bgw);
  2408.         }
  2409.     }
  2410. }
  2411.  
  2412. void do_menu(void)
  2413. {
  2414.     byte b;
  2415.     uchar ctlkey;
  2416.     int err;
  2417.     string ts;
  2418.     uchar yes[2],tpic[2];
  2419.  
  2420.     set_addmember(ExitSet,AltX);
  2421.     if (initdbm()) {
  2422.         for (b = 0; b < def1.anchor; b++) swapmenu();
  2423.         strcat(strcpy(uw.wfnam,applname),".DBW");
  2424.         err = initwin(&uw);
  2425.         if (err == 0) {
  2426.             if ((dm.curmnu->ym == 25) && (scrhgt > 25)) dm.curmnu->ym = scrhgt;
  2427.             datenpath();
  2428.             if (uw.bgw != NULL) uw.bgw->disp = True;
  2429.             strcat(strcpy(hw.wfnam,applname),".DBH");
  2430.             initwin(&hw);
  2431.             dispallwin();
  2432.             hidewin(T_ON,uw.wa[1]);
  2433.             top_record();
  2434.             quit = False;
  2435.             dspmnu(&dm,dm.curmnu);
  2436.             do {
  2437.                 if (dm.curitm->sec > gvar->sec) {
  2438.                     if (dm.curmnu->mtyp == Vert) goud(&dm,Down);
  2439.            else                         gorl(&dm,Right);
  2440.                 }
  2441.                 hbar(&dm);
  2442.                 tandk(0,0,uw.wa[scrno]);
  2443.                 ctlkey = upperch(getkey());
  2444.                 if ((dm.curitm->sec > gvar->sec) &&
  2445.                         ((ctlkey != AltX) && (ctlkey != AltL) && (ctlkey != QitKey)))
  2446.                     dberrm(LSC_MustLogOn);
  2447. /* [DG] 09/09/1992
  2448.  Restructured switch statement to allow (mostly) CUA-compliant hot-keys */
  2449.                 switch (ctlkey) {
  2450.                   case Enter    : if (gvar->sec >= dm.curitm->sec)
  2451.                                           do_ctl(&dm,dm.curitm); break;
  2452.                   case HlpKey   : itemhelp(&dm); break;
  2453. /* Next */    case CtrlRArr : do_proc( 1,&dm); break;
  2454. /* Prev */    case CtrlLArr : do_proc( 2,&dm); break;
  2455. /* Find */    case AltS     : do_proc( 3,&dm); break;
  2456. /* Top  */    case Home     : do_proc( 4,&dm); break;
  2457. /* Last */    case EndKey   : do_proc( 5,&dm); break;
  2458. /* Edit */    case CtrlEnter: do_proc( 6,&dm); break;
  2459. /* Add  */    case Ins      : do_proc( 7,&dm); break;
  2460. /* Copy */    case CtrlC    : do_proc( 8,&dm); break;
  2461. /* Del  */    case Del      : do_proc( 9,&dm); break;
  2462. /* +Fil */    case PgDn     : do_proc(10,&dm); break;
  2463. /* -Fil */    case PgUp     : do_proc(11,&dm); break;
  2464. /* ScSv */        case AltV     : do_proc(12,&dm); break;
  2465.                   case UArr     : if (dm.curmnu->mtyp != Vert) do_proc(2,&dm);
  2466.                                          else goud(&dm,Up); break;
  2467.                   case DArr     : if (dm.curmnu->mtyp != Vert) do_proc(1,&dm);
  2468.                                          else goud(&dm,Down); break;
  2469.                   case LArr     : gorl(&dm,Left); break;
  2470.                   case RArr     : gorl(&dm,Right); break;
  2471. ⁿIFDEF TABLESⁿ
  2472.                   case CtrlPgUp : if (tabsize[filno] > 1)
  2473.                                          next_tab_page(_Prev); break;
  2474.                   case CtrlPgDn : if (tabsize[filno] > 1)
  2475.                                          next_tab_page(_Next); break;
  2476. ⁿENDDEFⁿ
  2477.                   case AltX     : dbgetstr(ts,_Ch,LSC_QuitDataBase,
  2478.                                          chstr(yes,_YES),chstr(tpic,Pic_U),"",
  2479.                                             chkyesno,nohelp);
  2480.                                          quit = (bool)((ts[0] == _YES) &&
  2481.                                                           (exitcode != QitKey));
  2482.                                break;
  2483.               case QitKey   : if ((dm.curmnu != NULL) &&
  2484.                   (dm.curmnu->pmnu != 0))
  2485.                 {
  2486.                                   zapmnu(&dm,dm.curmnu);
  2487.                                   dm.curmnu->litm = dm.curitm;
  2488.                                   dm.curmnu = dm.mat[dm.curmnu->pmnu-1];
  2489.                                   dm.curitm = dm.curmnu->litm;
  2490.                                   dm.level = 0;
  2491.                                   if (dm.curmnu->winp == NULL)
  2492.                   dspmnu(&dm,dm.curmnu);
  2493.                              }
  2494.                                else
  2495.                 {
  2496.                 if (filno > 1)
  2497.                   switch_file('-');
  2498.                                   else
  2499.                   {
  2500.                                      dbgetstr(ts,_Ch,LSC_QuitDataBase,
  2501.                        chstr(yes,_YES),
  2502.                        chstr(tpic,Pic_U),"",
  2503.                        chkyesno,nohelp);
  2504.                                      quit = (bool)((ts[0] == _YES) &&
  2505.                            (exitcode != QitKey));
  2506.                                 }
  2507.                              }
  2508.                                break;
  2509.                     default      : if (selitm(ctlkey,&dm))
  2510.                 {
  2511.                                    hbar(&dm);
  2512.                                    do_ctl(&dm,dm.curitm);
  2513.                                   }
  2514.                                break;
  2515. /* End of changes       */
  2516.                 }
  2517.             } while (!quit);
  2518.         }
  2519.  
  2520.  
  2521.         else dberrm(strconcat(ts,DOSErr8," [",uw.wfnam,"]",NULL));
  2522.         if ((menuanchor != def1.anchor) || (deltas != def1.deltat)) {
  2523.             def1.anchor = menuanchor;
  2524.      def1.deltat = deltas;
  2525.             updexe(def1.exeid,sizeof(def1));
  2526.         }
  2527.         disposemnus(&dm);
  2528.         closeallwin();
  2529.     }
  2530.     else dberrm(strconcat(ts,_NoFiles," [",localmenu,"]",NULL));
  2531. }
  2532.  
  2533. void main(void)
  2534. {
  2535.     extfhc_init();
  2536.     db_curs_init();
  2537.     db_date_init();
  2538.     db_funcs_init();
  2539.     db_heap_init();
  2540.     db_gvar_init();
  2541.     db_key_init();
  2542.     db_pswd_init();
  2543.     db_win_init();
  2544.     db_util_init();
  2545.     db_work_init();
  2546.     db_tree_init();
  2547.     db_list_init();
  2548. ⁿIFDEF MANUALⁿ
  2549.     db_man_init();
  2550. ⁿENDDEFⁿ
  2551. ⁿIFDEF MEMOSⁿ
  2552.     db_mnu_init();
  2553.     db_memo_init();
  2554. ⁿELSEDEFⁿ
  2555.     db_mnu_init();
  2556. ⁿENDDEFⁿ
  2557. ⁿIFDEF MUSERⁿ
  2558.     multiuser = True;
  2559. ⁿELSEDEFⁿ
  2560.     multiuser = False;
  2561. ⁿENDDEFⁿ
  2562.     initedit();
  2563.     initindex();
  2564.     _keyexpr = keyexpr;
  2565.     _getarec = getarec;
  2566.     _horizrec = horizrec;
  2567.     clrscr();
  2568.     if (menudriven && !dbcaller) {
  2569.         audible(Error);
  2570.         dspmsge(LSC_BaseError,LSC_MenuDriven,4.0);
  2571.     }
  2572.     else if (!validpath()) {
  2573.         audible(Error);
  2574.         dspmsge(LSC_BaseError,LSC_AbortBadPath,4.0);
  2575.     }
  2576.     else {
  2577.         if (openwin(0,(byte)(80-strlen(LSC_Initializing))/2,12,
  2578.                                 (byte)strlen(LSC_Initializing),1,31,31,8,"─┐│┘─└│┌",TopCnt,"")) {
  2579.             twinp = curwin;
  2580.             writewxy(LSC_Initializing,31,1,1,twinp);
  2581.             hidewin(T_ON,twinp);
  2582.             openfiles();
  2583.             closewin(&twinp);
  2584.         }
  2585.         if (fok) {
  2586.             shutdown = on_error;
  2587.             initialize();
  2588. ⁿIFDEF MANUALⁿ
  2589.             initmanual("ⁿMANUALⁿ");
  2590. ⁿENDDEFⁿ
  2591.             do_menu();
  2592.             if (openwin(0,(80-strlen(LSC_ClosingFile))/2,12,
  2593.                                     (byte)strlen(LSC_ClosingFile),1,31,31,8,"─┐│┘─└│┌",TopCnt,"")) {
  2594.                 twinp = curwin;
  2595.                 writewxy(LSC_ClosingFile,31,1,1,twinp);
  2596.                 hidewin(T_ON,twinp);
  2597.                 closefiles();
  2598.                 closewin(&twinp);
  2599.             }
  2600.         }
  2601.         else {
  2602.             audible(Error);
  2603.             dspmsge(LSC_ErrNeededFiles,LSC_ErrMissingFile,5.0);
  2604.         }
  2605.     }
  2606.     clrscr();
  2607. }
  2608.